第二章——线性表

定义——逻辑结构

线性表是具有相同数据类型的$n(n>=0)$个数据元素的有限序列，其中$n$为表长，当$n=0$时线性表是一个空表。若用$L$命名线性表，则其一般表示为
$$L=(a_1,a_2,\dots ,a_i,\dots ,a_n)$$

要点：
每个数据元素所占空间一样大；有限个元素；元素之间有次序。
$a_i$是线性表中的“第i个”元素线性表中的位序。
$a_1$是表头元素；$a_n$是表尾元素。
除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。

基本操作——数据的运算

初始化表 InitList(&L) ：构造一个空的线性表。分配内存空间。
销毁操作 DestroyList(&L) ：销毁线性表，并释放线性表L所占用的内存空间

插入操作 ListInsert(&L,i,e) ：在表L中的第i个位置上插入指定元素e
删除操作 ListDelete(&L,i.&e) ：删除表L中第i个位置的元素，并用e返回删除元素的值。

按值查找操作 LocateElem(L,e) ：在表L中查找具有给定关键字值的元素
按位查找操作 GetElem(L,i) ：获取表L中第i个位置的元素的值

其他常用操作：
求表长 Length(L) ：返回线性表L的长度，即L中数据元素的个数。
输出操作 PrintList(L) ：按前后顺序输出线性表L的所有元素值。
判空操作 Empty(L) ：若L为空表，则返回true，否则返回false

要点：
1⃣️对数据的操作主要为——创销、增删改查
2⃣️C语言函数的定义——<返回值类型> 函数名 (<参数1类型> 参数1 , <参数2类型> 参数2, …)
3⃣️实际开发中，可根据实际需求定义其他的基本操作
4⃣️什么时候要传入引用“&”——对参数的修改结果需要“带回来”

void test(int & x) {
	x = 1024;
	printf("内部函数调用时x=%d\n", x);
}
int main() {
	int x = 1;
	printf("调用前x=%d\n", x);
	test(x);
	printf("调用后x=%d\n", x);
}

//输出结果为：
调用前x=1
内部函数调用时x=1024
调用后x=1024

插入 ListInsert(&L, i, e)

插入操作：在表L中的第i个位置上插入指定元素e。

想要在位序i处插入元素，需要将第i个元素之后的元素后移，总长度+1

#define InitSize 10  //默认的最大长度
 typedef struct{
     int data[MaxSize];     //
     int length;    //顺序表的当前长度
 }SqList;

bool ListInsert(SqList &L, int i, int e) {
    if(i<1||i>L.length+1) //判断i的范围是否有效
        return false;
    if(L.length>=MaxSize) //当前存储空间已满，不能插入
        return false;
    for(int j = L.length; j>=i; j--) {
        L.data[j] = L.data[j-1];    //将第i个元素及之后的元素后移
    } //注意位序，从后面的元素依次移动
    L.data[i-1] = e;    //在位置i处放入e
    L.length++;         //长度+1
    return true;
}

int main() {
    SqList L;
    InitList(L);
    //……插入几个元素
    ListInsert(L, 3, 3);
    return 0;
}

插入操作的时间复杂度

关注最深层循环语句的执行次数与问题规模n的关系
L.data[j] = L.data[j-1];
最好情况：新元素插入到表尾，不需要移动元素，i=n+1，循环0次；
$最好时间复杂度=O(1)$
最坏情况：新元素插入到表头，需要将原有的n个元素全部都向后移动，i=1，循环n次；
$最坏时间复杂度=O(n)$
平均情况：假设新元素插入到任何一个位置的概率相同，即$i=1，2，3，\dots ，length+1$的概率都是$P=1/(n+1)$
i=1，循环n次；i=2，循环n-1次；i=3，循环n-2次……i=n+1时，循环0次。
$平均循环次数=np+(n-1)p+...+1\ast p=n(n+1)/2(n+1)=n/2$
$平均时间复杂度=O(n)$

删除 ListDelete(&L, i, e)

删除操作：删除表L中dii个位置的元素，并用e返回删除元素的值。

bool ListDelete(SqList &L, int i, int &e) {
    if(i<1||i>L.length)
        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;
}

注意位序、数组下标的关系，并从前面的元素依次移动。

删除的时间复杂度

删除操作的时间复杂度与插入的时间复杂度相同
最好情况：删除表尾元素，不移动其他元素,$最好时间复杂度=O(1)$
最坏情况：删除表头元素,$最坏时间复杂度=O(n)$
平均情况：$O(n)$

查找 GetElem(L,i)

按位查找

获取表L中第i个位置的元素的值

ElemType GetElem(SqList L, int i) {
	return L.data[i-1];
}

时间复杂度：$O(1)$
由于顺序表的各个数据元素在内存中连续存放，因此可以根据起始地址和数据元素大小立即找到第i个元素

按值查找 LocateElem(L,e)

在表L中查找具有给定关键字值的元素

//在顺序表L中查找到第一个元素值等于e的元素，并返回其位序
int LocateElem(SeqList L, ElemType e) {
	for(int i = 0; i < L.length; i++)
		if(L.data[i] == e)
			return i+1;//数组下标为i的元素值等于e，返回其位序i+1
	return 0; //退出循环，说明查找失败
}

基本数据类型：int、char、double、float等可以直接用运算符==比较；
结构类型的数据元素不能直接使用== 比较；
若手写代码可直接使用==

时间复杂度：
最好情况：目标元素在表头；$O(1)$
最坏情况：目标元素在表尾；$O(n)$
平均情况：$O(n)$

存储结构——物理结构

顺序表（顺序存储）

用顺序存储的方式实现线性表
顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现

顺序表的实现——静态分配

#define MaxSize 10   //定义最大长度
typedef struct {
	ElemType data[MaxSize]; //用静态的“数组”存放数据元素
	int length;  //顺序表的当前长度
}SqList;  //顺序表的类型定义（静态分配方式）

如果不对每个元素初始化，初始化不彻底，内存中会有遗留的之前的数据没有被清理

遇到的问题：如果“数组”存满了？
存储空间是静态的，刚开始确定之后就无法更改

顺序表的实现——动态分配

#include <stdlib.h>
#define InitSize 10  //默认的最大长度
 typedef struct{
     int *data;     //指示动态分配数组的指针
     int MaxSize;   //顺序表的最大容量
     int length;    //顺序表的当前长度
 }SeqList;

 void InitList(SeqList &L) {
     //用 malloc 函数申请一片连续的存储空间
     L.data(int *)malloc(InitSize*sizeof(int));
     L.length=0;
     L.MaxSize=InitSize;
 }

 void IncreaseSize(SeqList &L, int len) {
     int *p = L.data;
     L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
     for(int i = 0; i<L.length; i++) {
         L.data[i]=p[i];    //将数据复制到新区域
     }
     L.MaxSize = L.MaxSize+len; //顺序表最大长度增加len
     free(p);   //释放原来的内存空间
 }

malloc、free函数在<stdlib.h>头文件中；
由于在动态扩展时，要将数据复制到新区域，所以会导致时间开销大

链表（链式存储）

链表分为：单链表、双链表、循环链表、静态链表
详细见文章：链表（线性表的一种存储结构）