1、线性表

a.定义：

有n（n>=0）个相同类型的元素组成的有序集合。

数组是线性表的一种。通常用数组实现。

b.线性表的顺序存储

b-1：顺序表结构体的定义

顺序表是一个结构体变量。结构体内部有两个数据：一个用于存放元素的数组，一个是记录数组中有效元素个数的整型变量。顺序表的数组中每增加一个元素，记录个数的整型变量就要加1；每减少一个元素，整型变量就要减一。通过记录元素个数的整型变量来访问数组的最后一个元素。

使用的代码

typedef struct
{
    ElemType data[MaxSize];//创建数组
    int length;//记录当前数组中有效数据的个数
}SqList;//给结构体重命名为SqList

用此结构体创建结构体变量，作为顺序表：SqList L

b-2：插入数据

①原理：

将元素x插入到第四个位置（也就是下标为3）的地方：

先将第四个位置及后面所有位置的元素，依次向后移动一位，从最后的元素开始移动。

平均移动元素的次数计算方法：

放在开头，放在末尾，分别移动n个元素，0个元素，两者求平均即为：n/2。

以此类推，将放在第二个位置，放在倒数第二个位置，两个一组，即可算出平均次数为：n/2。

②代码说明：

Ⅰ.子函数的写法说明

插入数据的代码，子函数需要引用顺序表。只有引用顺序表，在子函数内对顺序表进行插入操作才能影响外面的顺序表。

代码如下

bool ListInsert(SqList& L, int i, ElemType e)//使用引用，在子函数内对顺序表进行插入操作才能影响外面的顺序表.这里的i表示位置

Ⅱ.判断插入的位置是否合法：

插入的位置<1或者>length+1，则表示非法。

元素	1	2	3	4
插入的位置	1	2	3	length	length+1	length+2

插入的位置在length+1，则表示在最后一个元素后面的一个空间插入数据。若插入的位置比length+1大，则会造成空位的产生，不合法。返回false即可。

代码如下

if (i<1 || i>L.length + 1)//判断插入的位置是否合法
{
    return false;
}

Ⅲ.判断顺序表是否有空间可以插入：

将顺序表中记录数组元素个数的length变量与顺序表数组的最大容量MaxSize相比，若是length>=MaxSize，则不可插入，返回false。

代码如下

if (L.length >= MaxSize)//判断是否有空间可以插入
{
    return false;
}

Ⅳ.利用for循环，将插入位置及位置以后的数据后移一位

从最后的一个元素开始移动，利用记录数组元素个数的整型变量，访问最后一个元素。注意，这个元素个数就是元素位置，必须-1后才可以找到最后一个元素对应的空间。

for循环的区间是从最后一个位置开始，大于等于当前位置。

for (int j = L.length; j >= i; j--)//length是最后一个元素的位置，是最后一个元素后面一个空间的下标，length-1是最后一个元素的下标
{
    L.data[j] = L.data[j - 1];//将后面的元素向后移动一位。最后位置才是后移到的位置
}

Ⅴ.移动完后将插入的数据放到插入的位置即可

代码如下

L.data[i - 1] = e;//位置-1后，才能得到该位置对应的下标。

Ⅵ.最后将记录数组长度的变量length+1即可

代码如下

L.length++;

Ⅶ.整体代码如下：

bool ListInsert(SqList& L, int i, ElemType e)//使用引用，在子函数内对顺序表进行插入操作才能影响外面的顺序表.这里的i表示位置
{
    if (i<1 || i>L.length + 1)//判断插入的位置是否合法
    {
        return false;
    }
    if (L.length >= MaxSize)//判断是否有空间可以插入
    {
        return false;
    }
    for (int j = L.length; j >= i; j--)//length是最后一个元素的位置，是最后一个元素后面一个空间的下标，length-1是最后一个元素的下标
    {
        L.data[j] = L.data[j - 1];//将后面的元素向后移动一位
    }
    L.data[i - 1] = e;
    L.length++;
    return true;//走到此处，表示插入成功
}

b-3：删除数据

①原理：

将第i个位置的元素删除：

若是最后一个元素，需要控制下标，使其无法访问到最后一个空间即可。

若是中间的元素，则将改元素后面的所有元素，依次向前移动，进行覆盖即可。从最前面的元素开始前移。

平均移动元素的次数和增加时移动的次数计算方法一样，但是删除少了一个，所以分子是n-1。

②代码说明：

Ⅰ.子函数的写法说明

引用顺序表，引用存放删除的元素的变量，用于后期在主函数中使用删除的元素。

代码如下

bool ListDelete(SqList& L, int i, ElemType& e)//因为要将删除的元素传回到主函数中，所以存放删除的元素的变量需要借助引用，即可影响主函数中的变量

Ⅱ.判断删除的位置是否合法

删除的位置必须在1~length（闭区间）之内。若是在不在此范围内，则不合法，返回false。

插入和删除的区别：前半部分一样，后边部分，插入是最后一个位置+1（即length+1），删除是最后一个位置（即length）。两个都是大于号和小于号。

代码如下

if (i<1 || i>L.length)//删除的位置必须有元素，相对与插入，插入可以访问到最后元素+1的空间即length+1，但是删除只能访问到最后一个元素的空间也就是length
{
    return false;
}

Ⅲ.判断顺序表是否有元素可以删除

通过顺序表中的记录元素个数的变量来判断，若是变量个数为0，则说明没有元素可以删除，则直接返回false。

代码如下

if(L.length==0)
{
    return false;
}

Ⅳ.将要删除的位置处的元素放到用于存放删除元素的变量中

注意：知道位置，位置-1后，才是对应的位置的下标，才能访问该位置的空间。

代码如下：

e = L.data[i - 1];//获取删除位置处对应的元素

Ⅴ.使用for循环，将删除位置后面的元素依次前移

从最前面的元素开始前移。直到最后一个元素结束

代码如下

for (int j = i; j < L.length; j++)
{
    L.data[j - 1] = L.data[j];//删除位置-1，才是前移到的位置
}

Ⅵ.记录数组元素个数的变量-1

代码如下

L.length--;

Ⅶ.整体代码如下

bool ListDelete(SqList& L, int i, ElemType& e)//因为要将删除的元素传回到主函数中，所以存放删除的元素的变量需要借助引用，即可影响主函数中的变量
{
	if (i<1 || i>L.length)//删除的位置必须有元素，相对与插入，插入可以访问到最后元素+1的空间即length+1，但是删除只能访问到最后一个元素的空间也就是length
	{
		return false;
	}
	if (L.length == 0)
	{
		return false;
	}
	e = L.data[i - 1];//获取删除位置处对应的元素
	for (int j = i; j < L.length; j++)
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	return true;
}

b-4：查找元素

Ⅰ.子函数的写法说明

返回值是int，因为返回的是该元素的位置，若是该元素不存在，则返回0，也可说明位置不存在。不需要借助引用。

代码如下

int LocateElem(SqList L, ElemType e)

Ⅱ.借助for循环，遍历顺序表，查看是否有该元素

在for循环内部使用if进行判断，若是某一个元素与指定元素相同，则返回该元素的位置。若是没有，则在for循环结束后返回0即可。

代码如下

int LocateElem(SqList L, ElemType e)
{
	for (int j = 0; j < L.length; j++)
	{
		if (L.data[j] == e)
		{
			return j + 1;
		}
	}
	return 0;
}

b-5：总结顺序表

顺序表是一个结构体变量。结构体内部有两个数据：一个用于存放元素的数组，一个是记录数组中有效元素个数的整型变量。顺序表的数组中每增加一个元素，记录个数的整型变量就要加1；每减少一个元素，整型变量就要减一。通过记录元素个数的整型变量来访问数组的最后一个元素。

涉及的代码

#define MaxSize 50
typedef int ElemType;//顺序表中的元素类型
typedef struct
{
	ElemType data[MaxSize];//创建数组
	int length;//记录当前数组中有效数据的个数
}SqList;//给结构体重命名为SqList

bool ListInsert(SqList& L, int i, ElemType e)//使用引用，在子函数内对顺序表进行插入操作才能影响外面的顺序表.这里的i表示位置
{
	if (i<1 || i>L.length + 1)//判断插入的位置是否合法
	{
		return false;
	}
	if (L.length >= MaxSize)//判断是否有空间可以插入
	{
		return false;
	}
	for (int j = L.length; j >= i; j--)//length是最后一个元素的位置，是最后一个元素后面一个空间的下标，length-1是最后一个元素的下标
	{
		L.data[j] = L.data[j - 1];//将后面的元素向后移动一位
	}
	L.data[i - 1] = e;
	L.length++;
	return true;//走到此处，表示插入成功
}
//删除使用元素e的引用的目的是拿出对应的值
bool ListDelete(SqList& L, int i, ElemType& e)//因为要将删除的元素传回到主函数中，所以存放删除的元素的变量需要借助引用，即可影响主函数中的变量
{
	if (i<1 || i>L.length)//删除的位置必须有元素，相对与插入，插入可以访问到最后元素+1的空间即length+1，但是删除只能访问到最后一个元素的空间也就是length
	{
		return false;
	}
	if (L.length == 0)
	{
		return false;
	}
	e = L.data[i - 1];//获取删除位置处对应的元素
	for (int j = i; j < L.length; j++)
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	return true;
}
//查找成功，返回位置，位置从1开始；查找失败，返回0
int LocateElem(SqList L, ElemType e)
{
	for (int j = 0; j < L.length; j++)
	{
		if (L.data[j] == e)
		{
			return j + 1;
		}
	}
	return 0;
}
void PrintList(SqList L)//打印顺序表中的数据
{
	for (int i = 0; i < L.length; i++)
	{
		printf("%3d", L.data[i]);//将所有元素打印到同一行
	}
	printf("\n");
}
int main()
{
	SqList L;//创建循序表，命名为L：顺序表是一个结构体，内部有一个存放元素的数组，还有一个记录数组元素个数的整型变量
	bool ret;//创建bool类型的变量，命名为ret。bool类型的变量只能赋值为True，或者False
	ElemType del;//存储要删除的元素
	L.data[0] = 1;//手动给顺序表中的数组添加数据。
	L.data[1] = 2;
	L.data[2] = 3;
	L.length = 3;//顺序表中的数组每增加一个元素，记录元素个数的整型变量就要加一
	ret = ListInsert(L, 2, 60);//向顺序表L的第二个位置插入60这个元素
	if (ret)
	{
		printf("插入成功\n");
		PrintList(L);//打印插入成功后的顺序表
	}
	else {
		printf("插入失败\n");
	}
	ret = ListDelete(L, 1, del);//将顺序表L的第一个位置的元素删除，并将删除的元素传回到主函数中
	if (ret)
	{
		printf("删除成功\n");
		printf("删除的元素值为%d\n", del);
		PrintList(L);
	}
	else {
		printf("删除失败\n");
	}
	int elem_pos;
	elem_pos = LocateElem(L, 60);
	if (elem_pos)
	{
		printf("查找成功\n");
		printf("元素位置为%d\n", elem_pos);
	}
	else {
		printf("查找失败\n");
	}
	return 0;
}

C.线性表的链式存储

见02-4文件