数据结构严蔚敏----动态顺序表基本操作12个

编程语言：C
编译环境：Dev-C++
源代码：
//线性表的动态分配顺序存储结构
//12个基本操作
//1.Status InitList(SqList *L) 构造一个空的顺序表L
// 数组的基地址elem进行赋值(ElemType )malloc(LIST_INIT_SIZEsizeof(ElemType))，判断是否赋值成功，若失败，exit(OVERFLOW);
// 长度length赋初值0，存储总容量listsize赋初值LIST_INIT_SIZE，return OK;
//2.Status DestroyList(SqList *L) 销毁顺序表L，前提L存在
// 释放(free)数组基址，置为NULL，length和listsize置为0，return OK;
//3.Status ClearList(SqList *L) 将L重置为空表，前提L存在
// length置为0，return OK;
//4.Status ListEmpty(SqList L) 探空，前提L存在
// 若length==0 return TRUE;否则return FALSE;
//5.int ListLength(SqList L) 返回长度，即L中数据元素的个数，前提L存在
// return L.length;
//6.Status GetElem(SqList L,int i,ElemType *e) 用e返回L中第i个数据元素的值，前提L存在
// 先判断i是否在1和L.length之间，若不在，return ERROR;
// 令e指向数组elem下标为i-1的数据元素，return OK;
//7.int LocateElem(SqList L,ElemType e) 若e在L中存在，返回它的位置，否则返回0，前提L存在
// 令ElemType *p指向数组第一个数据元素，令int i=1;
// 若i<=L.length&&*p!=e，i++，p++，最后若i>L.length，说明e在L中不存在，return 0;否则return i;
//8.Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e) 用pre_e返回L中cur_e的前驱元素，前提L存在
// 令ElemType p指向数组第二个数据元素，令int i=2;如果cur_e恰好为第一个数据元素，它就没有前驱，所以cur_e恰好为第一个数据元素的可能性不用考虑
// 若i<=L.length&&p!=e，i++，p++，最后若i>L.length，说明cur_e在L中不存在，return ERROR;否则令pre_e等于(–p)，return OK;
//9.Status NextElem(SqList L,ElemType cur_e,ElemType *next_e) 用next_e返回L中cur_e的后继元素，前提L存在
// 令ElemType p指向数组第一个数据元素，令int i=1;
// 若i<=L.length&&p!=e，i++，p++，最后若i>=L.length，说明cur_e在L中不存在或恰好为最后一个数据元素，return ERROR;否则令next_e等于(++p)，return OK;
//10.Status ListInsert(SqList *L,int i,ElemType e) 在L中第i个位置之前插入新的数据元素e，L的长度加1，前提L存在
// 先判断i是否在1和L.length+1之间，若不在，return ERROR;
// 然后判断是否需要增加存储空间，若(*L).length>=(*L).listsize，则需要增加
// 数组的新基址ElemType *newbase进行赋值(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType))
// 判断是否赋值成功，若失败，exit(OVERFLOW);
// 令(*L).elem=newbase;(*L).listsize+=LISTINCREMENT;
// 令ElemType *q指向数组第i个数据元素
// 令ElemType p指向数组最后一个数据元素
// 若p>=q，(p+1)=p，p–，该循环用于进行后移操作
// 最后令q=e;++(*L).length;return OK;
//11.Status ListDelete(SqList *L,int i,ElemType *e) 删除L的第i个数据元素，并用e返回其值，L的长度减1，前提L存在
// 先判断i>=1&&i<=(*L).length，若不是，return ERROR;此处也包含了L为空表不能进行删除的情况
// 令ElemType *q指向数组第i个数据元素，即待删除元素
// 令ElemType p指向数组最后一个数据元素
// 令e=q，在进行删除操作（即前移操作）之前必须将待删除的元素值赋给e，因为删除结束后就找不到了
// q++，若q<=p，(q-1)=*q ，q++，该循环用于进行前移操作
// 最后–(*L).length;return OK;
//12.Status ListTraverse(SqList L) 顺序表的遍历：依次访问表中每一个元素，前提L存在
// 令ElemType *p指向数组第一个数据元素，令int i=1;
// 若i<=L.length，printf("%d “,*p)，p++，i++
// 最后printf(”\n");return OK;
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;
//线性表的动态分配存储结构
#define LIST_INIT_SIZE 10
#define LISTINCREMENT 5
typedef struct {
ElemType *elem;//数组基址
int length;//当前长度
int listsize;//当前存储空间
}SqList;
//1.构造一个空的顺序表L
Status InitList(SqList *L)
{
(*L).elem=(ElemType )malloc(LIST_INIT_SIZEsizeof(ElemType));
if(!(*L).elem) exit(OVERFLOW);//判断
(*L).length=0;
(*L).listsize=LIST_INIT_SIZE;
return OK;
}
//2.销毁顺序表L，前提L存在
Status DestroyList(SqList *L)
{
free((*L).elem);
(*L).elem=NULL;
(*L).length=0;
(*L).listsize=0;
return OK;
}
//3.将L重置为空表，前提L存在
Status ClearList(SqList *L)
{
(*L).length=0;
return OK;
}
//4.探空，前提L存在
Status ListEmpty(SqList L)
{
if(L.length==0)
return TRUE;
else
return FALSE;
}
//5.返回长度，即L中数据元素的个数，前提L存在
int ListLength(SqList L)
{
return L.length;
}
//6.用e返回L中第i个数据元素的值，前提L存在
Status GetElem(SqList L,int i,ElemType *e)
{
if(i<1||i>L.length)
return ERROR;
else
{
*e=L.elem[i-1];
return OK;
}
}
//7.若e在L中存在，返回它的位置，否则返回0，前提L存在
int LocateElem(SqList L,ElemType e)
{
ElemType *p=L.elem;
int i=1;
while(i<=L.length&&*p!=e)
{
i++;
p++;
}
if(i>L.length)
return 0;
else
return i;
}
//8.用pre_e返回L中cur_e的前驱元素，前提L存在
Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e)
{
ElemType *p=L.elem+1;
int i=2;
while(i<=L.length&&*p!=cur_e)
{
i++;
p++;
}
if(i>L.length)
return ERROR;
else
{
pre_e=(–p);
return OK;
}
}
//9.用next_e返回L中cur_e的后继元素，前提L存在
Status NextElem(SqList L,ElemType cur_e,ElemType *next_e)
{
ElemType *p=L.elem;
int i=1;
while(i<=L.length&&*p!=cur_e)
{
i++;
p++;
}
if(i>=L.length)
return ERROR;
else
{
next_e=(++p);
return OK;
}
}
//10.在L中第i个位置之前插入新的数据元素e，L的长度加1，前提L存在
Status ListInsert(SqList *L,int i,ElemType e)
{
if(i<1||i>(*L).length+1)
return ERROR;
if((*L).length>=(*L).listsize)
{
ElemType *newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW);
(*L).elem=newbase;
(*L).listsize+=LISTINCREMENT;
}
ElemType *q=(*L).elem+i-1;
ElemType *p=(*L).elem+(*L).length-1;
while(p>=q)
{
*(p+1)=*p;
p–;
}
*q=e;
++(*L).length;
return OK;
}
//11.删除L的第i个数据元素，并用e返回其值，L的长度减1，前提L存在
Status ListDelete(SqList *L,int i,ElemType *e)
{
if(i<1||i>(*L).length)
return ERROR;
ElemType *q=(*L).elem+i-1;
ElemType *p=(*L).elem+(*L).length-1;
*e=*q;
q++;
while(q<=p)
{
*(q-1)=*q;
q++;
}
–(*L).length;
return OK;
}
//12.顺序表的遍历：依次访问表中每一个元素，前提L存在
Status ListTraverse(SqList L)
{
ElemType *p=L.elem;
int i=1;
while(i<=L.length)
{
printf("%d “,*p);
i++;
p++;
}
printf(”\n");
return OK;
}
int main()
{
SqList L;
int j,j1;
ElemType e=0,e1=0;
printf(“测试第一个基本操作（构造空顺序表）\n”);
InitList(&L);
printf(“L.elem=%d,L.length=%d,L.listsize=%d\n”,L.elem,L.length,L.listsize);
printf("\n\n测试第十个基本操作（插入数据元素）\n");
for(j=1;j<=5;j++)
ListInsert(&L,1,j);
printf(“在表头依次插入1~5后，L.elem=%d,L.length=%d,L.listsize=%d\n”,L.elem,L.length,L.listsize);
printf(“此时顺序表中的元素为：”);
ListTraverse(L);
printf(“第十二个基本操作测试成功！\n”);
printf("\n\n继续测试第十个基本操作，这次主要测试增加分配是否正确\n");
for(j=6;j<=11;j++)
ListInsert(&L,j,j);
printf(“在表尾依次插入6~11后，L.elem=%d,L.length=%d,L.listsize=%d\n”,L.elem,L.length,L.listsize);
printf(“此时顺序表中的元素为：”);
ListTraverse(L);
printf("\n\n测试第三、第四个基本操作：\n");
printf(“顺序表是否为空（1为空，0为不空）：%d\n”,ListEmpty(L));
ClearList(&L);
printf(“表清空后，顺序表是否为空（1为空，0为不空）：%d\n”,ListEmpty(L));
printf(“L.elem=%d,L.length=%d,L.listsize=%d\n”,L.elem,L.length,L.listsize);
printf("\n\n在表尾依次插入1~18。\n");
for(j=1;j<=18;j++)
ListInsert(&L,j,j);
printf(“L.elem=%d,L.length=%d,L.listsize=%d\n”,L.elem,L.length,L.listsize);
printf(“此时顺序表中的元素为：”);
ListTraverse(L);
printf("\n\n测试第五个基本操作（返回数据元素个数）\n");
printf(“表中数据元素的个数为%d\n”,ListLength(L));
printf("\n\n测试第六个基本操作（返回第十八个、第十九个数据元素的值）\n");
GetElem(L,18,&e);
GetElem(L,19,&e1);
printf(“第十八个数据元素为%d,第十九个数据元素为%d\n”,e,e1);
printf("\n\n测试第七个基本操作\n");
j=LocateElem(L,18);
j1=LocateElem(L,19);
printf(“18的位序为%d,19的位序为%d\n”,j,j1);
printf("\n\n测试第八个基本操作\n");
e=0;
e1=0;
PriorElem(L,1,&e);
PriorElem(L,18,&e1);
printf(“1的前驱为%d,18的前驱为%d\n”,e,e1);
printf("\n\n测试第九个基本操作\n");
e=0;
e1=0;
NextElem(L,1,&e);
NextElem(L,18,&e1);
printf(“1的后继为%d,18的后继为%d\n”,e,e1);
printf("\n\n测试第十一个基本操作\n");
e=0;
ListDelete(&L,6,&e);
printf(“删除第六个数据元素：%d\n”,e);
printf(“L.elem=%d,L.length=%d,L.listsize=%d\n”,L.elem,L.length,L.listsize);
printf(“此时顺序表中的元素为：”);
ListTraverse(L);
printf("\n\n测试第十二个操作\n");
DestroyList(&L);
printf(“销毁顺序表后，L.elem=%d,L.length=%d,L.listsize=%d\n”,L.elem,L.length,L.listsize);
return 0;
}

运行结果：