第二章 线性表及其顺序存储方式

1、线性表的定义与操作

1.1、基本概念

线性表是具有相同数据类型的n（n>=0）个数据元素组成的有限序列，其中 n 为表长，当 n = 0 线性表是一个空表。
表头元素：唯一的第一个元素
表尾元素：唯一的最后一个数据元素
除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继续。
线性表特点：

• 表中元素的个数有限
• 表中元素具有逻辑上的顺序性，表中元素有其先后次序
• 表中元素都是数据元素，每个元素都是单个元素
• 表中元素的数据类型都相同，即每个元素占有相同大小的存储空间
• 表中元素具有抽象性，即讨论元素之间的逻辑关系，而不考虑元素究竟表示什么内容
  注： 线性表是一种逻辑结构，表示元素之间一对一的相邻关系。顺序表和链表是指存储结构。
  线性表中元素的位序是从1开始的，而数组中元素的下标是从0开始的。注意区分。

1.2、基本操作

基本上每中结构都会有的操作：增删改查，创建，销毁，判空操作

2、线性表的顺序表示

2.1、顺序表的概念

顺序表是线性表的顺序存储方式，使得逻辑上相邻的元素在物理位置上也相邻，因为这种特性，线性表的顺序存储结构是一种随机存储的存储结构。
tip：若知道顺序表的第一个元素起始位置地址为 A，则 在第 i 处的地址为 A + i * sizeof(ElemType)

2.1、顺序表的静态分配

定义顺序表前，先将一些常用的变量进行定义，这里使用书写代码

#include <stdio.h>

// 定义需要的类型
#define true 1
#define false 0
#define MaxSize 10

typedef char bool;  // 给基本数据类型起别名，方便修改操作
typedef int ElemType;

2.1.1、定义一个顺序表并进行初始化顺序表

// 定义一个顺序表
typedef struct SqList {
	ElemType data[MaxSize];  // 顺序表的元素
	int length;  // 顺序表的当前长度
}SqList;

// 初始化一个顺序表
void InitList(SqList* L) {
	for (int i = 0; i < MaxSize; i++) {
		L->data[i] = 0;  // 将所有数据元素设置初始值为0，此步可以省略，但可能有脏数据
	}
	L->length = 0;  // 此步不可以省略，必须对顺序表当前长度设置为0
}

2.1.2、顺序表的插入

对顺序表进行插入删除操作时，因为其中的元素是在物理上相邻的，因此进行插入和删除操作后需要对元素进行移位。
若在顺序表位序 i 进行插入操作，需要从表尾直到位序 i+1 位后的所有元素进行后移操作。
大家自己在编写代码的时候，可以现在图上画一下流程，能有更好的理解，也可避免出错

// 顺序表按位序插入，需要传入顺序表，位序以及要插入的元素
bool ListInsert(SqList* L, int i, ElemType e) {  
	// 判断位序是否越界，使代码具有健壮性
	if (i < 1 || i > L->length+1)
		return false;
	// 判断是否数据已满
	if (L->length == MaxSize)
		return false;  // 这一步其实可以跟上面一起判断，只是判断的用处不同，此处分开
	// 插入，注意数组下标从0开始，故比位序少1，同时长度也会比数组下标多1，不要混淆
	for (int j = L->length; j >= i; j--) {
		L->data[j] = L->data[j - 1];
	}
	L->length++;  // 需要对当前元素长度++
	L->data[i - 1] = e;

	return true;
}

顺序表的插入操作的平均时间复杂度与最坏时间复杂度：O(n)，最好时间复杂度：O(1)

2.1.3、顺序表的删除

将顺序表的第 i 位删除的时候，需要将顺序表的第 i + 1 位直到表尾元素进行前移操作
此处对于 for 循环的结束判断与王道不一样，大家可以在纸上画一下流程理解

// 顺序表按位删除，需要传入顺序表，位序，以及被删除的元素
bool ListDelete(SqList* L, int i, ElemType *e) {
	if (i < 1 || i > L->length)
		return false;
	*e = L->data[i - 1];  // 返回被删除的元素
	for (int j = i - 1; j < L->length - 1; j++)
		L->data[j] = L->data[j + 1];
	L->length--;  // 删除或插入数据表的元素，一定不要忘记对表长进行修改
	return true;
}

顺序表的删除操作的平均时间复杂度与最坏时间复杂度：O(n)，最好时间复杂度：O(1)

2.1.4、顺序表的按位查找

// 顺序表的按位查找，需要传入顺序表，位序
ElemType GetElem(SqList L, int i) {
	return L.data[i - 1];
}

时间复杂度：O(1)

2.1.5、顺序表的按值查找

// 顺序表的按值查找，并返回位序
int LocateElem(SqList L, ElemType e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] == e)
			return i + 1;
	}
	return 0;
}

顺序表的按值查找操作的平均时间复杂度与最坏时间复杂度：O(n)，最好时间复杂度：O(1)

2.1.6、对顺序表方法进行测试

int main() {
	// 声明一个顺序表
	SqList L;
	// 对顺序表进行初始化
	InitList(&L);

	// 对顺序表进行插入操作
	for (int i = 0; i < 4; i++) {
		ListInsert(&L, i + 1, i + 1);
	}
	printfList(L);
	ListInsert(&L, 2, 10);
	printfList(L);

	// 对顺序表进行删除操作
	ElemType e;
	if (!ListDelete(&L, 2, &e))
		printf("位序越界\n");
	else {
		printf("被删除的元素位: %d\n", e);
		printf("被删除后的顺序表为：\n");
		printfList(L);
	}

	// 顺序表的按位查找
	printf("位序为%d的元素为: %d\n", 3, GetElem(L, 3));
	// 顺序表的按值查找
	e = LocateElem(L, 8);
	if (e)
		printf("没有此元素\n");
	else
		printf("被查找到的元素位序为%d\n", e);

	return 0;
}

2.2、顺序表的动态分配

顺序表的基本操作在静态分配中已经实现了，接下来使用动态分配来建立顺序表，此处不在分开书写。
动态分配需要使用到 malloc() 申请内存空间以及 free() 释放内存空间，这两个函数包含在头文件<stdlib.h> 中

动态顺序表的插入删除和静态顺序表的插入删除思想并无区别，代码也类似，此处不在重复撰写，读者们有兴趣可以自行编程

#include <stdlib.h>
#include <stdio.h>

#define true 1
#define false 0
#define InitSize 10

typedef char bool;
typedef int ElemType;

typedef struct SqList {
	ElemType* data;
	int MaxSize;  // 顺序表的最大长度
	int length;
}SqList;

// 初始化动态顺序表
void InitList(SqList* L) {
	// 用 malloc 函数申请一片连续的存储空间
	L->data = (ElemType*)malloc(sizeof(ElemType));
	L->MaxSize = InitSize;
	L->length = 0;
}

// 增加动态数组的长度
void IncreaseSize(SqList* L, int len) {
	// 先用一个指针指向需要保存的数据元素
	ElemType* p = L->data;
	// 重新申请一片连续的存储空间
	L->MaxSize = L->MaxSize + len;  // 先修改最大长度
	L->data = (ElemType*)malloc(sizeof(ElemType) * L->MaxSize);
	for (int i = 0; i < L->length; i++) {
		L->data[i] = p[i];
	}
	free(p);  // 释放原来的内存空间
}

int main() {
	// 声明一个动态顺序表
	SqList L;
	InitList(&L);
	printf("当前顺序表的最大长度为: %d\n", L.MaxSize);
	IncreaseSize(&L, 50);
	printf("当前顺序表的最大长度为: %d\n", L.MaxSize);
	return 0;
}