顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。

采用顺序存储结构的线性表简称为“ 顺序表”。顺序表的存储特点是：只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L 1≤i≤n 其中，L是元素占用存储单元的长度。

顺序表的结构定义：

#define maxlen 50 //定义顺序表中元素个数最多有几个

typedef struct

{

elementtype data[maxlen]; //elementtype是元素的类型 依具体情况而定

int listlen; //便于时刻了解顺序表里元素的个数

}seqlist; //顺序表的名称 不妨为seqlist

声明顺序表类型变量：

seqlist L,L1;

如顺序表的每个结点占用len个内存单元，用location (ki)表示顺序表中第i个结点ki所占内存空间的第1个单元的地址。则有如下的关系:location (ki+1) = location (ki) +len

location (ki) = location(k1) + (i-1)len

存储结构要体现数据的逻辑结构，顺序表的存储结构中，内存中物理地址相邻的结点一定具有顺序表中的逻辑关系。

基本操作

Status InitList(SqList &L) // 算法2.3

{ // 操作结果：构造一个空的顺序线性表

L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));

if(!L.elem)

exit(OVERFLOW); // 存储分配失败

L.length=0; // 空表长度为0

L.listsize=LIST_INIT_SIZE; // 初始存储容量

return OK;

}

Status DestroyList(SqList &L)

{ // 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L

free(L.elem);

L.elem=NULL;

L.length=0;

L.listsize=0;

return OK;

}

Status ClearList(SqList &L)

{ // 初始条件：顺序线性表L已存在。操作结果：将L重置为空表

L.length=0;

return OK;

}

Status ListEmpty(SqList L)

{ // 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE

if(L.length==0)

return TRUE;

else

return FALSE;

}

int ListLength(SqList L)

{ // 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数

return L.length;

}

Status GetElem(SqList L,int i,ElemType &e)

{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)

// 操作结果：用e返回L中第i个数据元素的值

if(i<1||i>L.length)

exit(ERROR);

e=*(L.elem+i-1);

return OK;

}

int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))

{ // 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0)

// 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。

// 若这样的数据元素不存在，则返回值为0。算法2.6

ElemType *p;

int i=1; // i的初值为第1个元素的位序

p=L.elem; // p的初值为第1个元素的存储位置

while(i<=L.length&&!compare(*p++,e))

++i;

if(i<=L.length)

return i;

else

return 0;

}

Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e)

{ // 初始条件：顺序线性表L已存在

// 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，

// 否则操作失败，pre_e无定义

int i=2;

ElemType *p=L.elem+1;

while(i<=L.length&&*p!=cur_e)

{

p++;

i++;

}

if(i>L.length)

return INFEASIBLE;

else

{

pre_e=*--p;

return OK;

}

}

Status NextElem(SqList L,ElemType cur_e,ElemType &next_e)

{ // 初始条件：顺序线性表L已存在

// 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，

// 否则操作失败，next_e无定义

int i=1;

ElemType *p=L.elem;

while(i<L.length&&*p!=cur_e)

{

i++;

p++;

}

if(i==L.length)

return INFEASIBLE;

else

{

next_e=*++p;

return OK;

}

}

Status ListInsert(SqList &L,int i,ElemType e) // 算法2.4

{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1

// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1

ElemType *newbase,*q,*p;

if(i<1||i>L.length+1) // i值不合法

return ERROR;

if(L.length>=L.listsize) // 当前存储空间已满,增加分配

{

if(!(newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType))))

exit(OVERFLOW); // 存储分配失败

L.elem=newbase; // 新基址

L.listsize+=LISTINCREMENT; // 增加存储容量

}

q=L.elem+i-1; // q为插入位置

for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移

*(p+1)=*p;

*q=e; // 插入e

++L.length; // 表长增1

return OK;

}

Status ListDelete(SqList &L,int i,ElemType &e) // 算法2.5

{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)

// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1

ElemType *p,*q;

if(i<1||i>L.length) // i值不合法

return ERROR;

p=L.elem+i-1; // p为被删除元素的位置

e=*p; // 被删除元素的值赋给e

q=L.elem+L.length-1; // 表尾元素的位置

for(++p;p<=q;++p) // 被删除元素之后的元素左移

*(p-1)=*p;

L.length--; // 表长减1

return OK;

}

Status ListTraverse(SqList L,void(*vi)(ElemType&))

{ // 初始条件：顺序线性表L已存在

// 操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败

// vi()的形参加'&'，表明可通过调用vi()改变元素的值

ElemType *p;

int i;

p=L.elem;

for(i=1;i<=L.length;i++)

vi(*p++);

cout<<endl;

return OK;

}