前言

部分内容摘自程杰的《大话数据结构》

1. 线性表的定义

线性表（List）：零个或多个数据元素的有限序列。
线性表是一个序列，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且只有一个前驱和后继。
然后，线性表强调是有限的，元素个数也是有限的。事实上，在计算机中处理的对象都是有限的，那种无限的数列，只存在于数学的概念中。
如果用数学语言来进行定义。可如下：
若将线性表记为（a $_1$ ，···，a $_i$ $_-$ $_1$ ，a $_i$ ，a $_i$ $_+$ $_1$ ，···，a $_n$ ），则表中 a $_i$ $_-$ $_1$ 领先于 a $_i$ ，a $_i$ 领先于 a $_i$ $_+$ $_1$ ，称 a $_i$ $_-$ $_1$ 是 a $_i$ 的直接前驱元素，a $_i$ $_+$ $_1$ 是 a $_i$ 的直接后继元素。当 i=1，2，…，n-1 时，a $_i$ 有且仅有一个直接后继，当 i=2，3，…，n 时，a $_i$ 有且仅有一个直接前驱。

所以线性表元素的个数n (n>0)定义为线性表的长度，当n=0时，称为空表。
在非空表中的每个数据元素都有一个确定的位置，如 a $_i$ 是第一个数据元素，a $_n$ 是最后一个数据元素，a $_i$ 是第 i 个数据元素，称 i 为数据元素 a $_i$ 在线性表中的位序。
在较复杂的线性表中，一个数据元素可以由若干个数据项组成。

2. 线性表的抽象数据类型

抽象数据类型（abstract data type，ADT）是带有一组操作的一些对象的集合。
对于线性表来说，插入数据和删除数据都是最基本且必须的操作。所以，线性表的抽象数据类型定义如下：
线性表的数据对象集合为{a $_1$ ，a $_2$ ，……，a $_n$ )，每个元素的类型均为 DataType。其中，除第一个元素 a $_1$ 外，每一个元素有且只有一个直接前驱元素，除了最后一个元素 a $_n$ 外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。

ADT 线性表 (List)
Data
operation
	InitList(*I):初始化操作，建立一个空的线性表L。
	ListEmpty(L):若线性表为空，返回true，否则返回false。
	ClearList(*L）:将线性表清空。
	GetElem(L,i,*e):将线性表L中的第i个位置元素值返回给e。
	LocateElem (L,e):在线性表L中查找与给定值e相等的元素，如果查找成功,返回该元素在表中序号表示成功;否则,返回0表示失败。
	ListInsert(*L,i,e):在线性表L中的第i个位置插入新元素e。
	ListDelete (*L,i,*e):删除线性表工中第i个位置元素，并用e返回其值。
	ListLength (L):返回线性表工的元素个数。
endADT

对于不同的应用，线性表的基本操作是不同的，上述操作是最基本的，对于实际问题中涉及的关于线性表的更复杂操作，完全可以用这些基本操作的组合来实现。

比如，要实现两个线性表集合A和B的并集操作。即要使得集合 A=A∪B。说白了，就是把存在集合B中但并不存在A中的数据元素插入到A中即可。
仔细分析一下这个操作，发现我们只要循环集合B中的每个元素，判断当前元素是否存在A中，若不存在，则插入到A中即可。思路应该是很容易想到的。
我们假设La表示集合A，Lb表示集合B，则实现的代码如下：

/* 将所有的在线性表Lb中但不在La中的数据元素插入到La中 */
void union(SqList *La,SqList Lb)
{
	int La_len,Lb_len,i;
	ElemType e;				/* 声明与La和Lb相同的数据元素e */
	La_len=ListLength(*La);	/* 求线性表的长度 */
	Lb_len=ListLength(Lb);
	for (i=1;;i<=Lb_len;i++)
	{
		GetElem(Lb,i,&e):	/* 取Lb中第i个数据元素赋给e */
		if (!LocateElem(*La,e)) /* La中不存在和e相同数据元素 */
			ListInsert (La,++La_len,e);	/* 插入 */
	}
}

这里，我们对于union操作，用到了前面线性表基本操作 ListLength、GetElem、LocateElem、ListInsert 等，可见，对于复杂的个性化的操作，其实就是把基本操作组合起来实现的。

注意一个很容易混淆的地方：
当你传递一个参数给函数的时候，这个参数会不会在函数内被改动决定了使用什么参数形式。
如果需要被改动，则需要传递指向这个参数的指针。
如果不用被改动，可以直接传递这个参数。

3. 线性表的顺序存储结构

3.1 顺序存储定义

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。
线性表（a $_1$ ，a $_2$ ，…，a $_n$ ）的顺序存储示意图如下：

3.2 顺序存储方式

线性表的顺序存储结构，说白了，就是在内存中找了块地儿，通过占位的形式，把一定内存空间给占了，然后把相同数据类型的数据元素依次存放在这块空地中。既然线性表的每个数据元素的类型都相同，所以可以用C语言（其他语言也相同）的一维数组来实现顺序存储结构，即把第一个数据元素存到数组下标为 0 的位置中，接着把线性表相邻的元素存储在数组中相邻的位置。
为了建立一个线性表，要在内存中找一块地，于是这块地的第一个位置就非常关键，它是存储空间的起始位置。线性表中，我们估算这个线性表的最大存储容量，建立一个数组，数组的长度就是这个最大存储容量。
同样的，我们已经有了起始的位置，也有了最大的容量，于是我们可以在里面增加数据了。随着数据的插入，我们线性表的长度开始变大，不过线性表的当前长度不能超过存储容量，即数组的长度。

来看线性表的顺序存储的结构代码：

#define MAXSIZE 20		/* 存储空间初始分配量 */
typedef int ElemType;	/* ElemType类型根据实际情况而定，这里为int */
typedef struct
{
	ElemType data[MAXSIZE]:	/* 数组，存储数据元素 */
	int length;				/* 线性表当前长度 */
}SqList;

这里，我们就发现描述顺序存储结构需要三个属性：

存储空间的起始位置：数组data，它的存储位置就是存储空间的存储位置。
线性表的最大存储容量：数组长度 MAXSIZE。
线性表的当前长度：length。

3.3 数组长度和线性表长度的区别

数组的长度是存放线性表的存储空间的长度，存储分配后这个量是一般是不变的。那么数组的大小一定不可以变吗？不是的，一般高级语言，比如C、VB、C++都可以用编程手段实现动态分配数组，不过这会带来性能上的损耗。
线性表的长度是线性表中数据元素的个数，随着线性表插入和删除操作的进行，这个量是变化的。
在任意时刻，线性表的长度应该小于等于数组的长度。

3.4 地址计算方法

由于我们数数都是从 1 开始数的，线性表的定义也不能免俗，起始也是 1，可C语言中的数组却是从 0 开始第一个下标的，于是线性表的第i个元素是要存储在数组下标为i-1的位置，即数据元素的序号和存放它的数组下标之间存在对应关系。

用数组存储顺序表意味着要分配固定长度的数组空间，由于线性表中可以进行插入和删除操作，因此分配的数组空间要大于等于当前线性表的长度。
其实，内存中的地址，就和图书馆或电影院里的座位一样，都是有编号的。存储器中的每个存储单元都有自己的编号，这个编号称为地址。当我们占座后，占座的第一个位置确定后，后面的位置都是可以计算的。试想一下，我是班级成绩第五名，我后面的 10 名同学成绩名次是多少呢？当然是6,7,…,15，因为5+1,5+2,…,5+10。由于每个数据元素，不管它是整型、实型还是字符型，它都是需要占用一定的存储单元空间的。假设占用的是 c 个存储单元，那么线性表中第i+1个数据元素的存储位置和第主个数据元素的存储位置满足下列关系（LOC表示获得存储位置的函数）：

$LOC(a{_i}{_+}{_1})=LOC(a_i)+c$

所以对于第i个数据元素 a $_i$ 的存储位置可以由 a $_1$ 推算得出：

$LOC(a_i)=LOC(a_1)+(i-1)*c$

通过这个公式，你可以随时算出线性表中任意位置的地址，不管它是第一个还是最后一个，都是相同的时间。那么我们对每个线性表位置的存入或者取出数据，对于计算机来说都是相等的时间，也就是一个常数，因此用我们算法中学到的时间复杂度的概念来说，它的存取时间性能为O(1)。我们通常把具有这一特点的存储结构称为随机存取结构。

4. 顺序存储结构的插入与删除

4.1 获得元素操作

对于线性表的顺序存储结构来说，如果我们要实现 GetElem 操作，即将线性表L中的第i个位置元素值返回，其实是非常简单的。就程序而言，只要i的数值在数组下标范围内，就是把数组第i-1下标的值返回即可。来看代码：

#define OK 1
#define ERROR O
/* Status是函数的类型，其值是函数结果状态代码，如OK等 */
typedef int status;

/* 初始条件:顺序线性表工已存在，1≤i≤ListLength(L) */
/* 操作结果:用e返回工中第i个数据元素的值，注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem (SqList L,int i,ElemType *e)
{
	if(L.length==0 || i<1 || i>L.length)
		return ERROR;
	*e=L.data[i-1];
	
	return OK;
}

注意这里我们是把指针*e的值给修改成L.data[i+1]，这就是真正要返回的数据，函数返回值只不过是函数处理的状态，返回值类型 Status 是一个整型，返回 OK 代表 1，ERROR 代表 0。

4.2 插入操作

插入算法的思路：

如果插入位置不合理，抛出异常；
如果线性表长度大于等于数组长度，则抛出异常或动态增加容量；
从最后一个元素开始向前遍历到第 i 个位置，分别将它们都向后移动一个位置；
将要插入元素填入位置 i 处；
表长加 1。

实现代码如下：

/* 初始条件:顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1 */
Status ListInsert (SqList *L,int i, ElemType e)
{
	int k;
	if (L->length==MAXSIZE)		/* 顺序线性表已经满 */
		return ERROR;
	if (i<1 || i>L->length+1)	/* 当i不在范围内时 */
		return ERROR;
		
	if (i<-L->length)		/* 若插入数据位置不在表尾 */
	{
		for (k=L->length-1;k>=i-1;k--)	/* 将要插入位置后数据元素向后移动一位 */
			L->data[k+1]=L->data[k];
	}
	L->data[i-1]=e;		/* 将新元素插入 */
	L->length++;
	
	return OK;
}

4.3 删除操作

删除算法的思路：

如果删除位置不合理，抛出异常;
如果线性长度大于等于数组长度，则抛出异常或动态增加容量；
从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置；
将要插入元素填入位置i处；
表长减 1。

实现代码如下：

/* 初始条件:顺序线性表L已存在，1≤i≤ListLength (L) */
/* 操作结果:删除工的第i个数据元素,并用e返回其值，L的长度减1 */
status ListDelete(sqList *L,int i,ElemType *e)
{
	int k;
	if (L->length==0)	/*线性表为空*/
		return ERROR;
	if (i<1 || i>L->length)		/* 删除位置不变 */
		return ERROR;
	*e=L->data[i-1];
	if (i<L->length)	/* 如果删除不是最后位置 */
	{
		for(k=i;k<L->length;k++)	/* 将删除位置后继元素前移 */
			L->data[k-1]=L->data[k];
	}
	L->length--;
	return OK;

现在我们来分析一下，插入和删除的时间复杂度。
先来看最好的情况，如果元素要插入到最后一个位置，或者删除最后一个元素，此时时间复杂度为O(1)，因为不需要移动元素的。
最坏的情况呢，如果元素要插入到第一个位置或者删除第一个元素，此时时间复杂度是多少呢？那就意味着要移动所有的元素向后或者向前，所以这个时间复杂度为o(n)。
至于平均的情况，由于元素插入到第1个位置，或删除第i个元素，需要移动n-i个元素。根据概率原理，每个位置插入或删除元素的可能性是相同的，也就说位置靠前，移动元素多，位置靠后，移动元素少。最终平均移动次数和最中间的那个元素的移动次数相等，为 $\frac{n-1}{2}$ 。
我们前面讨论过时间复杂度的推导，可以得出，平均时间复杂度还是O(n)。
这说明什么？线性表的顺序存储结构，在读数据时，不管是哪个位置，时间复杂度都是O(1)；而插入或删除时，时间复杂度都是O(n)。这就说明，它比较适合元素个数不太变化，而更多是存取数据的应用。

4.4 线性表顺序存储结构的优缺点

优点：

无须为表示表中元素之间的逻辑关系而增加额外的存储空间；
可以快速地存取表中任一位置的元素；

缺点：

插入和删除操作需要移动大量元素；
当线性表长度变化较大时，难以确定存储空间的容量；
造成存储空间的“碎片”；

5. 总结

线性表是零个或多个具有相同类型的数据元素的有限序列。
线性表的两大存储结构：顺序存储结构和链式存储结构。
相比链式存储结构，顺序存储结构比较容易理解，是用一段连续的存储单元依次存储线性表的数据元素。通常用数组来实现这一结构。
下一篇博客再具体说线性表的另一个存储结构：链式存储结构。