顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
简介
将表中元素一个接一个的存入一组连续的
存储单元中，这种
存储结构是
顺序结构。
采用
顺序存储结构的线性表简称为“ 顺序表”。顺序表的存储特点是：只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L 1≤i≤n 其中，L是元素占用存储单元的长度。
顺序表的结构定义：
#define maxlen 50 //定义顺序表中元素个数最多有几个
{
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
存储结构要体现数据的
逻辑结构，顺序表的存储结构中，内存中
物理地址相邻的结点一定具有顺序表中的
逻辑关系。
基本操作
1.构造一个空的顺序线性表
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;
}
2.销毁顺序线性表L
Status DestroyList(SqList &L)
{ //
初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L
free(L.elem);
L.elem=NULL;
L.length=0;
L.listsize=0;
return OK;
}
3.将L重置为空表
Status ClearList(SqList &L)
{ // 初始条件：顺序线性表L已存在。操作结果：将L重置为空表
L.length=0;
return OK;
}
4.判断是否为空表
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)
if(i＜1||i＞L.length)
exit(ERROR);
e=*(L.elem+i-1);
return OK;
}
7.返回L中第1个与e满足关系，不存在，则
返回值为0
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;
}
8.是L的
数据元素，且不是第一个，则用
pre_e返回它的前驱
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;
}
}
9.cur_e是L的
数据元素，且不是最后一个，用next_e返回它的后继
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;
}
12.依次对L的每个
数据元素调用函数vi()。一旦vi()失败，则操作失败
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++);
return OK;
}