数据结构--顺序表

// SQLIST.H
/***************************************************************************
 * File: SQLIST.h
 * Author: suzhaoda ([email protected])
 *
 * 顺序表
 * ADT (List)
 * Data
 *   {a1, a2, a3, ..., an}
 * Operation
 *   InitList(*L);              初始化，建立一个空的顺序表L.
 *   ListEmpty(L);              如果顺序表为空,返回true,否则返回false.
 *   ClearList(*L);             将顺序表清空.
 *   GetElem(L, i, *e);         将顺序表L中第i个位置元素值返回给e.
 *   LocateElem(L, e);          在L查找和e相等的元素,成功返回元素所在的.
 *                              序号,否则,返回0表示失败.
 *   ListInsert(*L, i, e);      在L中第i个位置插入新元素e.
 *   ListDelete(*L, i, *e);     删除L中第i个位置的元素,并用e返回其值.
 *   ListLength(L);             返回线性表L的元素个数.
 *   DestroyList(*L);           释放L的内存.
 * ENDADT
 *
 * 逻辑结构
 *              |a1|a2|...|ai-1|ai|...|an|
 * 修改记录:
 *          2012-12-17 重新组织代码,编译调试,修正语法错误.
 */
#ifndef SQLIST_H_INCLUDED
#define SQLIST_H_INCLUDED

/************************data   顺序存储结构定义**************************/

#include <stdlib.h>
#define OK      1
#define ERROR   0
#define TRUE    1
#define FALSE   0
#define MAXSIZE 20              /* 存储空间初始分配量 */

typedef int ElemType;           /* ElemType 类型根据实际情况而定,现假设为 int */
typedef int Status;             /* Status 是函数的类型，其值是函数结果状态代码 */

typedef struct{
  ElemType data[MAXSIZE];       /* 数组存储数据元素， 最大值为 MAXSIZE */
  int length;                   /* 线性表当前长度  */
}SqList;

/***************************** operation 操作 *****************************/

/*
 * 初始条件：顺序表L未分配内存；
 * 操作结果：初始化，建立已经分配好内存的顺序表L；
 *           注意调用配套函数释放
 */
Status InitList(SqList* L);

/*
 * 初始条件：顺序线性表L已存在
 * 操作结果：如果顺序表为空，返回true，否则返回false
 */
Status ListEmpty(SqList L);

/*
 * 初始条件: 顺序线性表L已存在
 * 操作结果：将顺序表元素清空为0，长度置为0
 */
void ClearList(SqList* L);

/*
 * 初始条件：顺序线性表L已存在.
 * 操作结果：在L查找和e相等的元素，成功返回元素所在的序号，
 *           否则，返回0表示失败
 */
int LocateElem(SqList L, ElemType e);

/*
 * 初始条件：顺序线性表L已存在，1 <= i <= ListLength(L)
 * 操作结果：用e返回L中第i个元素的值
 */
Status GetElem(SqList L, int i, ElemType* e);

/*
 * 初始条件: 顺序线性表L已存在，i <= i <= ListLength(L)
 * 操作结果：在L中第i个位置之前插入新元素e , L的长度加1
 */
Status ListInsert(SqList* L, int i, ElemType e);

/*
 * 初始条件: 顺序线性表L已存在，i <= i <= ListLength(L)
 * 操作结果：删除在L中第i个数据元素，并用e返回其值 , L的长度减1
 */
Status ListDelete(SqList* L, int i, ElemType* e);

/*
 * 初始条件：顺序表L已经存在.
 * 操作结果：返回顺序表L的元素个数.
 */
int ListLength(SqList L);

/*
 * 初始条件： 顺序表L已经存在.
 * 操作结果； 释放内存.
 */
void DestroyList(SqList* L);


#endif // SQLIST_H_INCLUDED

// SQLIST.C

#include "SQLIST.h"

Status InitList(SqList* L)
{
  int i;

  /* 分配内存 */
  L = (SqList*) malloc(sizeof(SqList));
  if (NULL == L)
    return ERROR;

  /* 初始化顺序表元素值为0 */
  for(i = 0; i < MAXSIZE; i++) {
    L -> data[i] = 0;
  }
  L -> length = 0;

  return OK;
}

Status ListEmpty(SqList L)
{
  return (L.length == 0 ? TRUE : FALSE);
}

void ClearList(SqList* L)
{
  int i;

  for(i = 0; i < L -> length; i++)
    L -> data[i] = 0;

  L -> length = 0;
}

int LocateElem(SqList L, ElemType e)
{
  int i;

  /* 此处可以使用更快的算法 */
  for(i = 0; i < L.length; i++){
    if(L.data[i] == e)
      return i;
  }
  return 0;
}

Status GetElem(SqList L, int i, ElemType* e)
{
  if(L.length == 0 || i < 1 || i > L.length)
    return ERROR;
  *e = L.data[i - 1];
  return OK;
}

Status ListInsert(SqList* L, int i, ElemType e)
{
  int k;

  /* 顺序线性表已经满 */
  if(L -> length == MAXSIZE)
    return ERROR;

  /* 当i不在范围内时 */
  if(i < 1 || i > L -> length + 1)
    return ERROR;

  /* 若插入数据位置不在表尾 */
  if(i <= L -> length){
    /* 将要插入位置后数据元素往后移动一位 */
    for(k = L -> length - 1; k >= i - 1; k--)
      L -> data[k + 1] = L -> data[k];
  }
  /* 将新数据元素插入 */
  L -> data[i - 1] = e;
  L -> length++;
  return OK;
}

Status ListDelete(SqList* L, int i, ElemType* e)
{
  int k;

  /* 线性表为空 */
  if(L -> length == 0)
    return ERROR;

  /* 当i不在范围内时 */
  if(i < 1 || i > L -> length)
    return ERROR;

  *e = L -> data[i - 1];

  /* 如果删除不是最后位置 */
  if(i < L -> length){
    /* 将删除元素位置后继元素往前移 */
    for(k = i; k < L -> length; k++)
      L -> data[k - 1] = L -> data[k];
  }

  L -> length--;
  return OK;
}

int ListLength(SqList L)
{
  return L.length;
}

void DestroyList(SqList* L)
{
  free(L);
  L = NULL;
}

参考<大话数据结构>