数据结构 顺序表的基本操作 （C++ 版本）

首先是我们顺序表的储存结构：

typedef struct{
ElemType* elem;
int length;
int listsize;
}Sqlist;

        elem表示数组指针，length表示顺序表中元素的个数，listsize表示顺序表我们能接受的最多的元素个数，如果length == listsize的时候就说明顺序表已经满了，我们就需要使用realloc()函数来进行扩容。

然后就是我们需要实现的功能：

初始化、建表操作

                               InitList(&L);这里传递过去的都是指针，所以这里要用引用的形式，返回操作状态

销毁顺序表

                          DestroyList(&L);返回操作状态
清空顺序表 

                         ClearList(&L);返回操作状态
判断顺序表是否为空 

                         ListEmpty(L);返回0或者1，是否为空的状态
得到循序表的长度 

                          ListLength(L);返回长度整数
得到L中第i个元素的值 

                         GetElem(L,i,&e);返回操作状态，并且用e带回
找到第一个数值为e，并且返回相应的位置

                         LocateElem(L,e,equal);如果找不到则返回0
得到一个元素的前驱

                         PriorElem(L,e,&per_e);用per_e带回答案，返回操作后的状态
得到一个元素的后继 

                        NextElem(L,e,&next_e);用next_e带回答案，返回操作后的状态
在相应的位置插入元素

                        ListInsert(&L,pos,num);在pos位置插入num，返回操作之后的状态
删除相应位置的元素 

                       ListDelete(&L,pos,&num);删除pos位置的元素，用num带回，返回操作之后的状态
便利顺序表L输出元素

                      ListTraverse(L,print);便利输出顺序表，返回操作之后的状态

最后的实现过程：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

typedef int  Status;

//顺序表的存储结构定义
#define LIST_INIT_SIZE  100
#define LISTADD   10
typedef int ElemType;  //假设线性表中的元素均为整型
typedef struct{
ElemType* elem;
int length;
int listsize;
}Sqlist;

Status equal(ElemType c1,ElemType c2)//返回位置函数所传递的参数
{
//判断是否相等的函数
if(c1==c2)
return TRUE;
else
return FALSE;
}

// 1,  InitList(&L) 操作结果：构造一个空的顺序表L
Status InitList(Sqlist &L){
L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem) exit(OVERFLOW);//exit(-1) 存储空间失败
L.length=0;  //初始化空表长度为0
L.listsize=LIST_INIT_SIZE;  //初始化空表的存储总容量

return OK;  //返回状态码 1
}

// 2,  DestroyList(&L)  初始条件：顺序表L已存在。 操作结果：销毁顺序表L。
Status DestroyList(Sqlist &L){
free(L.elem);
L.elem=NULL;  //指向空
L.length=0;
L.listsize=0;

return OK;
}

//3,   ClearList(&L)  初始条件：顺序表L已经存在。操作结果：将L重置为空表。
Status ClearList(Sqlist &L){
L.length=0;  //清空当前长度
return OK;
}

//4,   ListEmpty(L)    初始条件：顺序表L已存在。操作结果：若顺序表L为空返回TRUE，否则返回FLASE。
Status ListEmpty(Sqlist L){
if(L.length==0)
return TRUE;
else
return FALSE;
}

//5,    ListLength(L)    初始条件：顺序表L已存在。操作结果：返回L中数据元素的个数。
int ListLength(Sqlist L){
return L.length;
}

//6,    GetElem(L,i,&e)  初始条件：顺序表L已存在(1<=i<=ListLength(L))。操作结果：用e返回L中i个数据元素的值。
Status  GetElem(Sqlist L,int i,ElemType &e){
if(i<1||i>L.length)
exit(ERROR);
e=L.elem[i-1];//*e=*(L.elem+i-1)
return OK;
}

//7,    LocateElem(L,e,compare())  初始条件：顺序表L已存在，compare()的数据元素判定函数。
//				操作结果：返回L中第1个与e的满足关系compare()的数据元素的位序。若这样的数据元素不存在，则返回0.
int  LocateElem(Sqlist L,ElemType e,Status (*compare)(ElemType,ElemType)){//compare()形参是函数指针
int i =1;            //i的初值为第一个元素的位序
ElemType *p=L.elem;  //p的初值为第一个元素的存储位置

while(i<=L.length && !(*compare)((*p++),e)){
++i;
}
if(i<=L.length)
return i;
else
return 0;
}

//8,    PriorElem(L,cur_e,&pre_e)  初始条件：顺序表L已存在。
//操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。
Status PriorElem(Sqlist L,ElemType cur_e,ElemType &pre_e){
ElemType *p =L.elem+1;  //指针变量p 指向第二个数据元素
int i =2;

while(i<=L.length && (*p)!=cur_e){  //注意不能写成，(*p++)!=cur_e,虽然它先判断*p，在+1，
//但是在条件不成立时会多后移一个位置
p++;
++i;
}
if(i>L.length){
return ERROR;
}else{
pre_e=(*--p);  //p先自减，pre_e就指向该数据元素的前驱结点
return OK;
}
}

//9,     NextElem(L,cur_e,&next_e)  初始条件：顺序表L已存在。
//操作结果：若cur_e是L的数据元素，且不是第一个，则用next_e返回它的前驱，否则操作失败，next_e无定义。
Status   NextElem(Sqlist L,ElemType cur_e,ElemType &next_e){
ElemType *p =L.elem;
int i=1;

while(i<L.length && (*p)!=cur_e){
p++;
++i;
}

if(i>=L.length){
return ERROR;
}else{
next_e =(*++p);  //next_e指向该数据元素的后继结点
return OK;
}
}

//10,   ListInsert(Sqlist *L,i,e)  初始条件：顺序表L已存在，1<=i<=ListLength(L)+1。
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert(Sqlist &L,int i,ElemType e){
if(i < 1 || i > L.length+1)//可以插入的最前面或者是最后面坐标分别为（1,L.length+1）
exit(ERROR);
if(L.length +1 == L.listsize)
{
L.elem = (ElemType *)realloc(L.elem,sizeof(L.listsize + LISTADD));
L.length += LISTADD;
}
for(int pos = L.length-1 ;pos >= i-1; pos --)
L.elem[pos+1] = L.elem[pos];
L.elem[i-1] = e;
L.length ++;
return OK;
}

//11, ListDelete(Sqlist &L,int i,ElemType &e) 初始条件：顺序线性表L已存在，1<=i<=ListLength(L)
Status ListDelete(Sqlist &L,int i,ElemType &e){
if(i < 1 || i > L.length )
exit(ERROR);
e = L.elem[i-1];
for(int pos = i-1;pos < L.length-1; pos ++)
L.elem[pos] = L.elem[pos+1];
L.length --;
return OK;
}

//12,  ListTraverse(L)   初始条件：顺序线性表L已存在。
Status ListTraverse(Sqlist L){
for(int i=0;i<L.length;i++)
{
if(i)
printf(" %d",L.elem[i]);
else
printf("%d",L.elem[i]);
}
printf("\n");
}

int main()
{
Sqlist L;
InitList(L);
DestroyList(L);
ClearList(L);
int k=ListEmpty(L);
int len=ListLength(L);
int e,index,per_e,next_e,num;
GetElem(L,index,e);
LocateElem(L,e,equal);
PriorElem(L,e,per_e);
NextElem(L,e,next_e);
int pos;
ListInsert(L,pos,num);
ListDelete(L,pos,num);
ListTraverse(L);
}

如果程序有错误的话，我会第一时间改正的......