线性表类型的实现——顺序映像（顺序存储结构），顺序表上的基本操作（初始化、查询、插入、删除）

线性表的顺序存储结构： 用一组地址连续的存储单元依次存放线性表中的数据元素。
它是实现线性表最简单的方法。

顺序存储结构的C语言描述：
对于线性表来说，可以开辟一个一维数组空间，来存储线性表的数据元素。由于线性表本身的长度是可变的，所以需要一个参量来指示当前的长度（length,对应线性表的逻辑结构）。而对于数组来说，它应该有一个当前分配的存储量（listsize,对应线性表的存储结构）。
另外，顺序存储结构俗称顺序表。

#define LIST_INIT_SIZE 80  //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量
typedef struct
{
  ElemType *elem;  //存储空间基址
  int length;  //当前长度
  int listsize; //当前分配的存储容量；以sizeof(ElemType)为单位
}SqList; //俗称 顺序表

在顺序表表示的情况下进行的基本操作：
【初始化操作】

//构造一个空的线性表
Status InitList_Sq(SqList &L)
{
	//给线性表的数据元素开辟一个一维的数组空间
	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;
}//InitList_Sq

【查询操作】

//在线型表L中找到第一个与e满足特定关系的数据元素的位序（查询操作）
int LocateElem_Sq(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	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;
}//LocateElem_Sq

这个操作的时间复杂度为：$O(ListLength(L))$,其中，$ListLength(L)$表示表长。

【插入操作】
插入元素时，线性表的逻辑结构发生了什么变化？很显然，（a₁, … a_i-1, a_i, …, a_n）改变为（a₁, … a_i-1, e, a_i, …, a_n），这个变化体现在两方面：（1）有序对<a_i-1, a_i>变成了有序对<a_i-1, e>和<e, a_i>；（2）长度增1。
这是相当于前i-1个元素（a₁, … a_i-1）不变，后n-i+1个元素（a_i, …, a_n）后移一位，最终长度增1。

//在线性表中第pos个位置上插入元素e
Status ListInsert_Sq(SqList &L, int pos, ElemType e)
{
    //算法的健壮性
	if (pos<1 || pos>L.length + 1) return ERROR;  //插入位置不合法
	if (L.length >= L.listsize)  //当前存储空间已满，增加分配
	{
		newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));//数组空间的再分配
		if (!newbase) exit(OVERFLOW);//存储分配失败
		L.elem = newbase;			//新基址
		L.listsize += LISTINCREMENT;//增加存储容量
	}
   
   //算法的主题
	q = &(L.elem[pos - 1]);     //q指示插入位置
	for (p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;//插入位置及之后的元素右移
	*q = e;   //插入e
	++L.length;//表长增1
	return OK;		
}

在第i个位置插入元素，移动元素的个数为$n-i+1$。
这个算法的时间复杂度为：$O(ListLength(L))$。
也可以考虑平均的情况：
假设在第i个元素之前插入的概率为p_i，则在长度为n的线性表中插入一个元素，所需移动元素次数的期望值为：
$E_{is}={\sum }_{i=1}^{n+1}{p}_i(n-i+1)$
若假定在线性表中任何一个位置上进行插入的概率都是相等的，则移动元素的期望值为：
$E_{is}=\frac{1}{n+1}{\sum }_{i=1}^{n+1}(n-i+1)=\frac{n}{2}$
为表长的一半。

【删除操作】
删除元素时，线性表的逻辑结构发生什么变化？很显然，（a₁, … a_i-1, a_i, a_i+1, …, a_n）改变为（a₁, … a_i-1, a_i+1, …, a_n），这个变化也体现在两个方面，与插入操作相反：（1）有序对<a_i-1, a_i>和<a_i, a_i+1>变成了有序对<a_i-1, a_i+1>；（2）表长减1。
这是相当于前i-1个元素（a₁, … a_i-1）不变，后n-i个元素（a_i+1, …, a_n）前移一位，最终长度减1。

//在线性表L中删除第pos个位置上的元素，并将删除的元素赋值给e
Status ListDelete_Sq(SqList &L, int pos, ElemType &e)
{
	//算法的健壮性
	if ((pos < 1) || (pos > L.length))  return ERROR;	//删除位置不合法

	//算法的主题
	p = &(L.elem[pos - 1]); //p为被删除元素的位置
	e = *p;   //被删除元素的位置赋给e
	q = L.elem + L.length - 1;//表尾元素的位置
	for (++p; p <= q; ++p)
		*(p - 1) = *p;     //被删除元素之后的元素前移
	--L.length;		//表长减1
	return OK;
}//ListDelete_Sq

时间复杂度是对于问题规模而言的，这时候需要忽略删除元素这个因素。
所以，这个算法的时间复杂度为：$O(ListLength(L))$。
也可以考虑平均的情况：
假设删除第i个元素的概率为q_i，则在长度为n的线性表中删除一个元素，所需移动元素次数的期望值为：
$E_{dl}={\sum }_{i=1}^n{q}_i(n-i)$
若假定在线性表中任何一个位置上进行插入的概率都是相等的，则移动元素的期望值为：
$E_{dl}=\frac{1}{n}{\sum }_{i=1}^n(n-i)=\frac{n-1}{2}$
大致也为表长的一半。

对顺序表的总结：
【优点】
可以对每个数据元素进行随机的存取，它的表长是显值。
【缺点】
在插入和删除数据元素的时候要进行元素的移动。每进行一次插入或删除，都要大致移动表的一半的元素。