数据结构学习笔记（王道）

PS：本文章部分内容参考自王道考研数据结构笔记

文章目录

• 数据结构学习笔记（王道）
• • 一、绪论
  • • 1.1. 数据结构
    • 1.2. 算法
    • • 1.2.1. 算法的基本概念
      • 1.2.2. 算法的时间复杂度
      • 1.2.3. 算法的空间复杂度
  • 二、线性表
  • • 2.1. 线性表的定义和操作
    • • 2.1.1. 线性表的基本概念
      • 2.1.2. 线性表的基本操作
    • 2.2. 顺序表
    • • 2.2.1. 顺序表的基本概念
      • 2.2.2. 顺序表的实现
      • 2.2.3. 顺序表的基本操作
    • 2.3. 链表
    • • 2.3.1. 单链表的基本概念
      • 2.3.2. 单链表的实现
      • 2.3.3. 单链表的插入
      • 2.3.4. 单链表的删除
      • 2.3.5. 单链表的查找
      • 2.3.6. 单链表的建立
      • 2.3.7. 双链表
      • 2.3.8. 循环链表
      • 2.3.9. 静态链表
      • 2.3.10. 顺序表和链表的比较
  • 三、栈与队列
  • • 3.1. 栈
    • • 3.1.1. 栈的基本概念
      • 3.1.2. 栈的基本操作
      • 3.1.3. 栈的顺序存储实现
      • 3.1.4. 栈的链式存储实现
    • 3.2. 队列
    • • 3.2.1. 队列的基本概念
      • 3.2.2. 队列的基本操作
      • 3.2.3. 队列的顺序存储实现
      • 3.2.4. 队列的链式存储实现
      • 3.2.5. 双端队列
    • 3.3. 栈与队列的应用
    • • 3.3.1 栈在括号匹配中的应用
      • 3.3.2. 栈在表达式求值中的应用
      • 3.3.3. 栈在递归中的应用
      • 3.3.4. 队列的应用
    • 3.4. 特殊矩阵的压缩存储
  • 四、串
  • • 4.1. 串的基本概念
    • 4.2. 串的基本操作
    • 4.3. 串的存储实现
    • 4.4. 串的朴素模式匹配
    • 4.5. KPM算法
  • 五、树
  • • 5.1. 树的概念
    • • 5.1.1. 树的定义和基本术语
      • 5.1.2. 树的常考性质
    • 5.2. 二叉树
    • • 5.2.1. 二叉树的定义
      • 5.2.2. 特殊二叉树
      • 5.2.3. 二叉树的性质
      • 5.2.4. 二叉树的实现
    • 5.3. 二叉树的遍历和线索二叉树
    • • 5.3.1. 二叉树的先中后序遍历
      • 5.3.2. 二叉树的层序遍历
      • 5.3.3. 由遍历序列构造二叉树
      • 5.3.4. 线索二叉树的概念
      • 5.3.5. 二叉树的线索化
      • 5.3.6. 在线索二叉树中找前驱/后继
    • 5.4. 树和森林
    • • 5.4.1. 树的存储结构
      • 5.4.2. 树和森林的遍历
    • 5.5. 应用
    • • 5.5.1. 二叉排序树
      • 5.5.2. 平衡二叉树
      • 5.5.3. 哈夫曼树
  • 六、图
  • • 6.1. 图的基本概念
    • 6.2. 图的存储
    • • 6.2.1. 邻接矩阵
      • 6.2.2. 邻接表
      • 6.2.3. 十字链表、临接多重表
      • 6.2.4. 图的基本操作
    • 6.3. 图的遍历
    • • 6.3.1. 广度优先遍历
      • 6.3.2. 深度优先遍历
    • 6.4. 图的应用
    • • 6.4.1. 最小生成树
      • 6.4.2. 无权图的单源最短路径问题——BFS算法
      • 6.4.3. 单源最短路径问题——Dijkstra算法
      • 6.4.4. 各顶点间的最短路径问题——Floyd算法
      • 6.4.5. 有向⽆环图描述表达式
      • 6.4.6. 拓扑排序
      • 6.4.7. 关键路径
  • 七、查找
  • • 7.1. 基本概念
    • 7.2. 顺序查找和折半查找
    • • 7.2.1. 顺序查找
      • 7.2.2. 折半查找
      • 7.2.3. 分块查找
    • 7.3. B树、B+树
    • • 7.3.1. B树
      • 7.3.2. B树的基本操作
      • 7.3.3. B+树
    • 7.4. 散列查找及其性能分析
    • • 7.4.1. 散列表的基本概念
      • 7.4.2. 散列函数的构造方法
      • 7.4.3. 处理冲突的方法
      • 7.4.4. 散列查找及性能分析
  • 八、排序
  • • 8.1. 排序的基本概念
    • 8.2. 插入排序
    • • 8.2.1. 直接插入排序
      • 8.2.2. 折半插入排序
      • 8.2.3. 希尔排序
    • 8.3. 交换排序
    • • 8.3.1. 冒泡排序
      • 8.3.2. 快速排序
    • 8.4. 选择排序
    • • 8.4.1. 简单选择排序
      • 8.4.2. 堆排序
    • 8.5. 归并排序和基数排序
    • • 8.5.1. 归并排序
      • 8.5.2. 基数排序
    • 8.6. 内部排序算法总结
    • • 8.6.1. 内部排序算法比较
      • 8.6.2. 内部排序算法的应用
    • 8.7. 外部排序
    • • 8.7.1. 外部排序的基本概念和方法
      • 8.7.2. 败者树
      • 8.7.3. 置换-选择排序（生成初始归并段）
      • 8.7.4. 最佳归并树

一、绪论

1.1. 数据结构

1. 数据：是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

2. 数据元素：数据的基本单位，一个数据元素可由若干数据项组成。

3. 数据项：数据的不可分割的最小单位。

4. 数据对象：性质相同的数据元素的集合，是数据的一个子集。

5. 数据结构：指互相之间存在着一种或多种特定关系的数据元素的集合，包括逻辑结构，存储结构和对数据的运算。（数据元素都不是孤立存在的）。

6. 抽象数据类型（ADT）：指一个数学模型以及定义在该模型上的一组操作，只取决于它的一组逻辑特性，用一个三元组表示（D, S, P）。

7. 数据类型：是程序设计语言中的一个概念，它是一个值的集合和操作的集合。

8. 逻辑结构：是指数据之间关系的描述，与数据的存储结构无关。分为线性结构和非线性结构，通常分为四类结构：

   1. 集合：结构中的数据元素除了同属于一种类型外，别无其它关系。
   2. 线性结构：结构中的数据元素之间存在一对一的关系。
   3. 树型结构：结构中的数据元素之间存在一对多的关系。
   4. 图状结构（网状结构）：结构中的数据元素之间存在多对多的关系。

9. 存储结构：是指数据结构在计算机中的表示，又称为数据的物理结构。它包括数据元素的表示和关系的表示，通常由四种基本的存储方法实现：

   1. 顺序存储方式。数据元素顺序存放，每个存储结点只含一个元素，存储位置反映数据元素间的逻辑关系，存储密度大。有些操作（如插入、删除）效率较差。
   2. 链式存储方式。每个存储结点除包含数据元素信息外还包含一组（至少一个）指针，指针反映数据元素间的逻辑关系。这种方式不要求存储空间连续，便于动态操作（如插入、删除等），但存储空间开销大（用于指针），且不能折半查找。
   3. 索引存储方式。除数据元素存储在一组地址连续的内存空间外，还需建立一个索引表，索引表中索引指示存储结点的存储位置（下标）或存储区间端点（下标）。
   4. 散列存储方式。通过散列函数和解决冲突的方法，将关键字散列在连续的有限的地址空间内，并将散列函数的值解释成关键字所在元素的存储地址。其特点是存取速度快，只能按关键字随机存取，不能顺序存取，也不能折半存取。

1.2. 算法

1.2.1. 算法的基本概念

1. 算法：是对特定问题求解步骤的一种描述，是指令的有限序列。其中每一条指令表示一个或多个操作。
2. 算法的特性：有穷性、确定性、可行性、输入、输出。
3. 算法的设计目标：正确性，可读性，健壮性，高效率与低存储量需求。

算法和程序十分相似，但又有区别。程序不一定具有有穷性，程序中的指令必须是机器可执行的，而算法中的指令则无此限制。算法代表了对问题的解，而程序则是算法在计算机上的特定的实现。一个算法若用程序设计语言来描述，则它就是一个程序。

1.2.2. 算法的时间复杂度

1. 如何计算：

   1. 找到一个基本操作（最深层循环)
   2. 分析该基本操作的执行次数x与问题规模n的关系 $x=f(n)$
   3. x的数量级$O(x)$就是算法时间复杂度$T(n)$：$O(x)=T(n)$

2. 常用技巧：

   1. 加法规则：$O(f(n))+O(g(n))=O(max(f(n),g(n)))$

   2. 乘法规则：$O(f(n))\times O(g(n))=O(f(n)\times g(n))$

   3. “常对幂指阶”
      O(1)<O(lo g 2n)<O(n)<O(nlo g 2n)<O( n 2)<O( n 3)<O( 2 n)<O(n!)<O( n n)O(1)<O(log_2n)<O(n)<O(nlog_2n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n) O(1)<O(log2​n)<O(n)<O(nlog2​n)<O(n2)<O(n3)<O(2n)<O(n!)<O(nn)

3. 三种复杂度：

   1. 最坏时间复杂度：考虑输入数据“最坏”的情况。
   2. 平均时间复杂度：考虑所有输入数据都等概率出现的情况。
   3. 最好时间复杂度：考虑输入数据“最好”的情况。

算法的性能问题只有在 n 很大时才会暴露出来

1.2.3. 算法的空间复杂度

1. 普通程序：

   1. 找到所占空间大小与问题规模相关的变量
   2. 分析所占空间 x 与问题规模 n 的关系 $x=f(n)$
   3. x 的数量级 $O(x)$ 就是算法空间复杂度 $S(n)$

2. 递归程序：

   1. 找到递归调用的深度x与问题规模n的关系 $x=f(n)$
   2. x的数量级 $O(x)$ 就是算法空间复杂度 $S(n)$

二、线性表

2.1. 线性表的定义和操作

2.1.1. 线性表的基本概念

1. 线性表：是具有相同数据类型的 n 个数据元素的有限序列。

2. 特点：

   • 存在惟一的第一个元素。

   • 存在惟一的最后一个元素。

   • 除第一个元素之外，每个元素均只有一个直接前驱。

   • 除最后一个元素之外，每个元素均只有一个直接后继。

3. 线性表的存储结构：

   • 顺序存储结构：顺序表
   • 链式存储结构：链表

2.1.2. 线性表的基本操作

1. InitList(&L)：初始化表。构造一个空的线性表 L，并分配内存空间。

2. DestroyList(&L)：销毁表。并释放线性表 L 占用的内存空间。

3. ListInsert(&L, i, &e)：插入操作。在表 L 的第 i 个位置插入指定元素 e 。

4. ListDelete(&L, i, &e)：删除操作。删除表 L 中第 i 个位置的元素，并用 e 返回删除元素的值。

5. LocateElem(L, e)：按值查找。在表 L 中查找具有给定元素值的元素。

6. GetElem(L, i)：按位查找。获取表 L 中第 i 个位置的元素的值。

7. Length(L)：求表长。返回线性表 L 的长度，即表中元素的个数。

8. PrintList(L)：打印表。按顺序输出线性表 L 的所有元素值。

9. Empty(L)：判断是否为空。若 线性表L 为空表，则返回 true，否则返回 false。

操作数据结构的思路：创销、增删改查

2.2. 顺序表

2.2.1. 顺序表的基本概念

1. 顺序表：用顺序存储的方式实现线性表。顺序存储，将逻辑上相邻的元素存储在相邻的物理位置上。

2. 特点：

   1. 随机访问，即可以在 $O(1)$ 时间内找到第 i 个元素。
   2. 存储密度高，每个节点只存储数据元素。
   3. 拓展容量不方便（即使使用动态分配的方式实现，拓展长度的时间复杂度也比较高，因为需要把数据复制到新的区域）。
   4. 插入删除操作不方便，需移动大量元素：$O(n)$

2.2.2. 顺序表的实现

静态实现：

#define MaxSize 10 // 定义最大长度 typedef struct {int data[MaxSize]; // 使用静态的数组存放数据元素 int length; // 顺序表的当前长度 }SqList;// 初始化顺序表 void InitList(SqList &L) {L.length = 0; // 顺序表初始长度为0 }int main() {SqList L; // 声明一个顺序表 InitList(L); // 初始化顺序表 return 0;}

动态实现：

#define InitSize 10 // 顺序表的初始长度typedef struct {int *data; // 声明动态分配数组的指针 int MaxSize; // 顺序表的最大容量int length; // 顺序表的当前长度 }SeqList;// 初始化顺序表 void InitList(SqList &L) {// 用malloc函数申请一片连续的存储空间 L.data = (int *)malloc(InitSize * sizeof(int));L.length = 0;L.MaxSize = InitSize;}// 增加动态数组的长度 void IncreaseSize(SqList &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); // 释放原来的内存空间 }int main() {SeqList L; // 声明一个顺序表 InitList(L); // 初始化顺序表 ...IncreaseSize(L, 5);return 0;}

malloc() 函数的作用：会申请一片存储空间，并返回存储空间第一个位置的地址，也就是该位置的指针。

2.2.3. 顺序表的基本操作

插入：

#define MaxSize 10 // 定义最大长度 typedef struct {int data[MaxSize]; // 用静态的数组存放数据元素 int length; // 顺序表的当前长度 }SqList;// 在顺序表i位置插入ebool 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--) // 将第i个元素之后的元素后移 L.data[j] = L.data[j-1];L.data[i-1] = e; // 在位置i处放入e L.length++; // 长度+1 return true;} int main() {SqList L;InitList(L);ListInsert(L, 3, 3);return 0; } 

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

删除：

#define MaxSize 10typedef struct {int data[MaxSize];int length;} SqList;// 删除顺序表i位置的数据并存入ebool ListDelete(SqList &L, int i, int &e) {if (i < 1 || i > L.length) // 判断i的范围是否有效return false;e = L.data[i-1]; // 将被删除的元素赋值给e for (int j = i; j < L.length; j++) //将第i个位置后的元素前移 L.data[j-1] = L.data[j];L.length--;return true; }int main() {SqList L;InitList(L);int e = -1;if (ListDelete(L, 3, e))printf("已删除第3个元素，删除元素值为%d\n", e);elseprintf("位序i不合法，删除失败\n"); return 0; } 

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

按位查找：

// 静态分配的按位查找#define MaxSize 10typedef struct {ElemType data[MaxSize]; int length;}SqList;ElemType GetElem(SqList L, int i) {return L.data[i-1];}

// 动态分配的按位查找#define InitSize 10typedef struct {ElemType *data;int MaxSize;int length;}SeqList;ElemType GetElem(SeqList L, int i) {return L.data[i-1];}

时间复杂度： $O(1)$

按值查找：

#define InitSize 10typedef struct {ElemType *data; int MaxSize;int length; }SqList;// 查找第一个元素值为e的元素，并返回其位序 int LocateElem(SqList 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; // 没有查找到 }

在《数据结构》考研初试中，手写代码可以直接用“==”，无论 ElemType 是基本数据类型还是结构类型

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

2.3. 链表

2.3.1. 单链表的基本概念

1. 单链表：用链式存储实现了线性结构。一个结点存储一个数据元素，各结点间的前后关系用一个指针表示。
2. 特点：
   1. 优点：不要求大片连续空间，改变容量方便。
   2. 缺点：不可随机存取，要耗费一定空间存放指针。
3. 两种实现方式：
   1. 带头结点，写代码更方便。头结点不存储数据，头结点指向的下一个结点才存放实际数据。
   2. 不带头结点，麻烦。对第一个数据结点与后续数据结点的处理需要用不同的代码逻辑，对空表和非空表的处理需要用不同的代码逻辑。

2.3.2. 单链表的实现

不带头结点的单链表：

typedef struct LNode{ElemType data;struct LNode *next;}LNode, *LinkList;//初始化一个空的单链表bool InitList(LinkList &L){L = NULL; //空表，暂时还没有任何结点return true;}void test(){LinkList L;//声明一个指向单链表的头指针//初始化一个空表InitList(L);...}//判断单链表是否为空bool Empty(LinkList L){return (L==NULL)}

带头结点的单链表：

typedef struct LNode{ElemType data;struct LNode *next;}LNode, *LinkList;// 初始化一个单链表（带头结点）bool InitList(LinkList &L){L = (LNode *)malloc(sizeof(LNode));//分配一个头结点 if (L == NULL)//内存不足，分配失败return false;L->next = NULL; //头结点之后暂时还没有结点 return true;}void test(){ LinkList L;//声明一个指向单链表的头指针 //初始化一个空表InitList(L); ...}//判断单链表是否为空bool Empty(LinkList L){if (L->next == NULL) return true; else return false;}

2.3.3. 单链表的插入

按位序插入（带头结点）：

typedef struct LNode{ ElemType data;struct LNode *next;}LNode, *LinkList;//在第i个位置插入元素ebool ListInsert(LinkList &L, int i, ElemType e){ if(i<1) return False; LNode *p; //指针p指向当前扫描到的结点int j=0;//当前p指向的是第几个结点 p = L;//循环找到第i-1个结点while(p!=NULL && j<i-1){ //如果i>lengh，p最后会等于NULL p = p->next;j++;} //p值为NULL说明i值不合法 if (p==NULL)return false; //在第i-1个结点后插入新结点LNode *s = (LNode *)malloc(sizeof(LNode)); s->data = e; s->next = p->next; p->next = s; //将结点s连到p后return true;}

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

按位序插入（不带头结点）：

typedef struct LNode{ ElemType data;struct LNode *next;}LNode, *LinkList;//在第i个位置插入元素ebool ListInsert(LinkList &L, int i, ElemType e){ //判断i的合法性 if(i<1)return false; //需要判断插入的位置是否是第1个 if(i==1){LNode *s = (LNode *)malloc(size of(LNode));s->data =e;s->next =L; L=s;//头指针指向新结点 return true;} //i>1的情况与带头结点一样，唯一区别是j的初始值为1 LNode *p; //指针p指向当前扫描到的结点 int j=1;//当前p指向的是第几个结点 p = L;//循环找到第i-1个结点while(p!=NULL && j<i-1){ //如果i>lengh，p最后会等于NULLp = p->next; j++;} //p值为NULL说明i值不合法 if (p==NULL) return false;//在第i-1个结点后插入新结点 LNode *s = (LNode *)malloc(sizeof(LNode));s->data = e;s->next = p->next;p->next = s;return true;}

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

除非特别声明，否则之后的代码都默认为带头结点！

指定结点的后插操作：

typedef struct LNode{ElemType data;struct LNode *next;}LNode, *LinkList;// 在结点p后插入元素ebool InsertNextNode(LNode *p, ElemType e){if(p==NULL){ return false; }LNode *s = (LNode *)malloc(sizeof(LNode)); if(s==NULL) return false;s->data = e; s->next = p->next;p->next = s; return true;}// 按位序插入的函数中可以直接调用后插操作bool ListInsert(LinkList &L, int i, ElemType e){if(i<1)return False;LNode *p; //指针p指向当前扫描到的结点 int j=0;//当前p指向的是第几个结点 p = L; //循环找到第i-1个结点 while(p!=NULL && j<i-1){ //如果i>lengh, p最后会等于NULL p = p->next;j++; } return InsertNextNode(p, e)}

时间复杂度：$O(1)$

指定结点的前插操作：

如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对q进行后插操作；

如果不传入头指针，可以在指定结点p后插入一个结点s，并交换两个结点所保存的数据，从而变相实现指定结点的前插操作。

typedef struct LNode{ ElemType data;struct LNode *next;}LNode, *LinkList;// 在结点p前插入元素ebool InsertPriorNode(LNode *p, ElemType e){if(p==NULL)return false;LNode *s = (LNode *)malloc(sizeof(LNode));// 内存不足分配失败 if(s==NULL) return false;// 将s插入结点p之后s->next = p->next; p->next = s; // 交换两个结点中的数据s->data = p->data; p->data = e; return true;}

时间复杂度：$O(1)$

2.3.4. 单链表的删除

按位序删除：

typedef struct LNode{ ElemType data;struct LNode *next;}LNode, *LinkList;// 删除第i个结点并将其所保存的数据存入ebool ListDelete(LinkList &L, int i, ElemType &e){if(i<1) return false; LNode *p; //指针p指向当前扫描到的结点 int j=0;//当前p指向的是第几个结点p = L; //循环找到第i-1个结点 while(p!=NULL && j<i-1){ //如果i>lengh，p和p的后继结点会等于NULLp = p->next;j++;} if(p==NULL) return false;if(p->next == NULL)return false; //令q暂时保存被删除的结点 LNode *q = p->next;e = q->data; p->next = q->next;free(q) return true;}

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

删除指定结点：

如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对p进行删除操作；

如果不传入头指针，可以把指定结点p的后继结点q删除，并使结点p保存结点q存储的数据，从而变相实现删除指定结点的操作。但是如果指定结点p没有后继结点，这么做会报错。

// 删除指定结点pbool DeleteNode(LNode *p){ if(p==NULL) return false; LNode *q = p->next; // 令q指向p的后继结点// 如果p是最后一个结点，则q指向NULL，继续执行就会报错p->data = q->data;p->next = q->next; free(q);return true;}

时间复杂度：$O(1)$

2.3.5. 单链表的查找

按位查找：

typedef struct LNode{ElemType data;struct LNode *next;}LNode, *LinkList;// 查找指定位序i的结点并返回LNode * GetElem(LinkList L, int i){ if(i<0)return NULL; LNode *p; int j=0; p = L;while(p!=NULL && j<i){ p = p->next; j++;}return p;}// 封装后的插入操作，在第i个位置插入元素e，可以调用查询操作和后插操作bool ListInsert(LinkList &L, int i, ElemType e){if(i<1) return False;// 找到第i-1个元素 LNode *p = GetElem(L, i-1); // 在p结点后插入元素e return InsertNextNode(p, e)}

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

按值查找：

// 查找数据域为e的结点指针，否则返回NULLLNode * LocateElem(LinkList L, ElemType e){ LNode *P = L->next; // 从第一个结点开始查找数据域为e的结点while(p!=NULL && p->data != e){ p = p->next; } return p;}

时间复杂度：

• 最好时间复杂度：$O(1)$
• 最坏时间复杂度：$O(n)$
• 平均时间复杂度：$O(n)$

计算单链表长度：

// 计算单链表的长度int Length(LinkList L){int len=0; //统计表长LNode *p = L;while(p->next != NULL){ p = p->next;len++; }return len;}

时间复杂度：$O(n)$

2.3.6. 单链表的建立

尾插法建立单链表：

// 使用尾插法建立单链表LLinkList List_TailInsert(LinkList &L){ int x;//设ElemType为整型intL = (LinkList)malloc(sizeof(LNode)); //建立头结点(初始化空表) LNode *s, *r = L;//r为表尾指针scanf("%d", &x); //输入要插入的结点的值 while(x!=9999){//输入9999表示结束 s = (LNode *)malloc(sizeof(LNode));s->data = x; r->next = s; r = s; //r指针指向新的表尾结点 scanf("%d", &x); }r->next = NULL;//尾结点指针置空return L;}

时间复杂度：$O(n)$

头插法建立单链表：

LinkList List_HeadInsert(LinkList &L){ //逆向建立单链表 LNode *s;int x; L = (LinkList)malloc(sizeof(LNode)); //建立头结点 L->next = NULL;//初始为空链表,这步很关键scanf("%d", &x); //输入要插入的结点的值while(x!=9999){//输入9999表结束 s = (LNode *)malloc(sizeof(LNode)); s->data = x;s->next = L->next;L->next = s;//将新结点插入表中，L为头指针 scanf("%d", &x); } return L;}

头插法实现链表的逆置：

// 将链表L中的数据逆置并返回LNode *Inverse(LNode *L){LNode *p, *q;p = L->next; //p指针指向第一个结点L->next = NULL;//头结点置空 // 依次判断p结点中的数据并采用头插法插到L链表中while (p != NULL){ q = p;p = p->next;q->next = L->next;L->next = q;} return L;}

具体解释详见【数据结构】单链表逆置：头插法图解

2.3.7. 双链表

1. **双链表的定义：**双链表也是链表的一种。双链表的每个数据节点中都有两个指针，分别指向前驱节点和后继结点。

2. 双链表的实现：

   typedef struct DNode{//定义双链表结点类型 ElemType data; //数据域struct DNode *prior, *next;//前驱和后继指针}DNode, *DLinklist;

3. 双链表的初始化 (带头结点)：

   typedef struct DNode{ ElemType data; struct DNode *prior, *next;}DNode, *DLinklist;// 初始化双链表bool InitDLinkList(Dlinklist &L){ L = (DNode *)malloc(sizeof(DNode)); if(L==NULL)return false;L->prior = NULL; //头结点的prior指针永远指向NULL L->next = NULL;//头结点之后暂时还没有结点，置空 return true;}void testDLinkList(){DLinklist L; InitDLinkList(L); ...}// 判断双链表是否为空bool Empty(DLinklist L){ if(L->next == NULL) return true;else return false;}

4. 双链表的后插操作：

   typedef struct DNode{ ElemType data; struct DNode *prior, *next;}DNode, *DLinklist;// 将结点s插入到结点p之后bool InsertNextDNode(DNode *p, DNode *s){ if(p==NULL || s==NULL)return false; s->next = p->next;// 判断结点p之后是否有后继结点if (p->next != NULL) p->next->prior = s; s->prior = p; p->next = s; return true;}

双链表的前插操作、按位序插入操作都可以转换成后插操作

5. 双链表的删除操作：

   // 删除p结点的后继结点bool DeletNextDNode(DNode *p){ if(p==NULL) return false; // 找到p的后继结点qDNode *q =p->next; if(q==NULL)return false;p->next = q->next; if(q->next != NULL) q->next->prior=p;free(q); return true;}// 销毁一个双链表bool DestoryList(DLinklist &L){ // 循环释放各个数据结点 while(L->next != NULL){DeletNextDNode(L);free(L);// 头指针置空L=NULL; }}

6. 双链表的遍历：

   // 向后遍历while(p!=NULL){// 对结点p做相应处理p = p->next;}// 向前遍历while(p!=NULL){// 对结点p做相应处理 p = p->prior;}// 跳过头结点的遍历while(p->prior!=NULL){ //对结点p做相应处理p = p->prior;}

双链表不可随机存取，按位查找、按值查找操作都只能用遍历的方式实现。

2.3.8. 循环链表

1. **循环链表的定义：**循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

2. 循环单链表的实现：

   typedef struct LNode{ ElemType data;struct LNode *next; }DNode, *Linklist;// 初始化循环单链表bool InitList(LinkList &L){L = (LNode *)malloc(sizeof(LNode));if(L==NULL) return false;// 最后一个结点的next指针指向头结点L->next = L; return true;}// 判断循环单链表是否为空bool Empty(LinkList L){if(L->next == L) return true;else return false;}// 判断结点p是否为循环单链表的表尾结点bool isTail(LinkList L, LNode *p){ if(p->next == L)return true;elsereturn false;}

3. 循环双链表的实现：

   typedef struct DNode{ElemType data; struct DNode *prior, *next;}DNode, *DLinklist;// 初始循环双链表bool InitDLinkList(DLinklist &L){L = (DNode *) malloc(sizeof(DNode));if(L==NULL)return false;// 头结点的prior指针指向最后一个结点，最后一个结点的next指针指向头结点 L->prior = L;L->next = L;}// 判断循环双链表是否为空bool Empty(DLinklist L){ if(L->next == L) return true;else return false;}// 判断结点p是否为循环双链表的表尾结点bool isTail(DLinklist L, DNode *p){ if(p->next == L)return true; elsereturn false;}

4. 循环双链表的插入和删除操作：

   // 将结点s插入到结点p之后bool InsertNextDNode(DNode *p, DNode *s){s->next = p->next; //循环双链表不用担心p结点的下一个结点为空 p->next->prior = s;s->prior = p; p->next = s;}// 删除p结点的后继结点bool DeletNextDNode(DNode *p){// 找到p的后继结点q DNode *q =p->next;//循环双链表不用担心q结点的下一个结点为空p->next = q->next;q->next->prior=p;free(q);return true;}

2.3.9. 静态链表

1. 静态链表的定义：用数组的方式实现的链表。分配一整片连续的内存空间，各个结点集中安置，每个结点包括了数据元素和下一个结点的数组下标。

2. 特点：

   • 优点：增、删操作不需要大量移动元素。
   • 缺点：不能随机存取，只能从头结点开始依次往后查找，容量固定不变！

3. 静态链表的定义：

   #define MaxSize 10//静态链表的最大长度struct Node{//静态链表结构类型的定义ElemType data;//存储数据元素int next; //下一个元素的数组下标};// 用数组定义多个连续存放的结点void testSLinkList(){struct Node a[MaxSize];//数组a作为静态链表, 每一个数组元素的类型都是struct Node...}

   也可以这么定义：

   #define MaxSize 10//静态链表的最大长度typedef struct{ //静态链表结构类型的定义 ELemType data;//存储数据元素 int next; //下一个元素的数组下标}SLinkList[MaxSize];void testSLinkList(){SLinkList a;}

   第一种是我们更加熟悉的写法，第二种写法则更加侧重于强调 a 是一个静态链表而非数组。

4. 静态链表的注意点：

   1. 初始化静态链表时，需要把a[0]的next设为-1，并将空闲结点的next设置为某个特殊值，比如-2。
   2. 按位序查找结点时，从头结点出发挨个往后遍历结点，时间复杂度 $O=(n)$。
   3. 按位序插入结点的步骤：①找到一个空的结点，存入数据元素；②从头结点出发找到位序为 i-1 的结点；③修改新结点的next 为 -1；④修改 i-1 号结点的next为新结点的下标；

2.3.10. 顺序表和链表的比较

1. 逻辑结构：顺序表和链表都属于线性表，都是线性结构。

2. 存储结构：

   • 顺序表：顺序存储

     • 优点：支持随机存取，存储密度高。
     • 缺点：大片连续空间分配不方便，改变容量不方便。

   • 链表：链式存储

     • 优点：离散的小空间分配方便，改变容量方便。
     • 缺点：不可随机存取，存储密度低。

3. 基本操作 – 创建：

   • 顺序表：需要预分配大片连续空间。若分配空间过小，则之后不方便拓展容量；若分配空间过大，则浪费内存资源。

     • 静态分配：静态数组，容量不可改变。
     • 动态分配：动态数组，容量可以改变，但是需要移动大量元素，时间代价高（使用malloc()、free()）。

   • 链表：只需要分配一个头结点或者只声明一个头指针。

4. 基本操作 – 销毁：

   • 顺序表：修改 Length = 0

     • 静态分配：静态数组——系统自动回收空间。
     • 动态分配：动态数组——需要手动free()。

   • 链表：依次删除各个结点 free()。

5. 基本操作 – 增/删：

   • 顺序表：插入 / 删除元素要将后续元素后移 / 前移；时间复杂度：$O(n)$，时间开销主要来自于移动元素。
   • 链表：插入 / 删除元素只需要修改指针；时间复杂度：$O(n)$，时间开销主要来自查找目标元素。

6. 基本操作 – 查找：

   • 顺序表
     • 按位查找：$O(1)$
     • 按值查找：$O(n)$，若表内元素有序，可在 $O(log2n)$ 时间内找到（二分法）
   • 链表：
     • 按位查找：$O(n)$
     • 按值查找：$O(n)$

三、栈与队列

3.1. 栈

3.1.1. 栈的基本概念

1. 栈是特殊的线性表：只允许在一端进行插入或删除操作，其逻辑结构与普通线性表相同。
2. 栈顶：允许进行插入和删除的一端 （最上面的为栈顶元素）。
3. 栈底：不允许进行插入和删除的一端 （最下面的为栈底元素）。
4. 空栈：不含任何元素的空表。
5. 特点：后进先出（后进栈的元素先出栈）、LIFO（Last In First Out）。
6. 缺点：栈的大小不可变，解决方法：共享栈。

3.1.2. 栈的基本操作

1. InitStack(&S)：初始化栈。构造一个空栈 S，分配内存空间。
2. DestroyStack(&S)：销毁栈。销毁并释放栈 S 所占用的内存空间。
3. Push(&S, x)：进栈。若栈 S 未满，则将 x 加入使其成为新的栈顶元素。
4. Pop(&S, &x)：出栈。若栈 S 非空，则弹出（删除）栈顶元素，并用 x 返回。
5. GetTop(S, &x)：读取栈顶元素。若栈 S 非空，则用 x 返回栈顶元素。
6. StackEmpty(S)：判空。断一个栈 S 是否为空，若 S 为空，则返回 true，否则返回 false。

3.1.3. 栈的顺序存储实现

顺序栈的定义：

#define MaxSize 10 //定义栈中元素的最大个数typedef struct{ElemType data[MaxSize]; //静态数组存放栈中元素int top;//栈顶元素}SqStack;void testStack(){SqStack S; //声明一个顺序栈(分配空间)}

顺序栈的初始化：

#define MaxSize 10typedef struct{ ElemType data[MaxSize];int top;}SqStack;// 初始化栈void InitStack(SqStack &S){ S.top = -1; //初始化栈顶指针}// 判断栈是否为空bool StackEmpty(SqStack S){if(S.top == -1)return true;elsereturn false;}

入栈出栈：

// 新元素进栈bool Push(SqStack &S, ElemType x){// 判断栈是否已满if(S.top == MaxSize - 1)return false;S.data[++S.top] = x;return true;}// 出栈bool Pop(SqStack &x, ElemType &x){// 判断栈是否为空if(S.top == -1)return false;x = S.data[S.top--];return true;}

读取栈顶元素：

// 读栈顶元素bool GetTop(SqStack S, ElemType &x){if(S.top == -1)return false;x = S.data[S.top];return true; }

共享栈（两个栈共享同一片空间）：

#define MaxSize 10 //定义栈中元素的最大个数typedef struct{ ElemType data[MaxSize]; //静态数组存放栈中元素int top0; //0号栈栈顶指针int top1; //1号栈栈顶指针}ShStack;// 初始化栈void InitSqStack(ShStack &S){S.top0 = -1;S.top1 = MaxSize; }

3.1.4. 栈的链式存储实现

链栈的定义：

typedef struct Linknode{ElemType data;//数据域Linknode *next; //指针域}Linknode,*LiStack;void testStack(){ LiStack L;//声明一个链栈}

链栈的初始化：

typedef struct Linknode{ ElemType data;Linknode *next;}Linknode,*LiStack;// 初始化栈bool InitStack(LiStack &L){L = (Linknode *)malloc(sizeof(Linknode)); if(L == NULL) return false; L->next = NULL;return true;}// 判断栈是否为空bool isEmpty(LiStack &L){if(L->next == NULL)return true; else return false;}

入栈出栈：

// 新元素入栈bool pushStack(LiStack &L,ElemType x){Linknode *s = (Linknode *)malloc(sizeof(Linknode));if(s == NULL) return false; s->data = x; // 头插法s->next = L->next;L->next = s; return true;}// 出栈bool popStack(LiStack &L, int &x){ // 栈空不能出栈if(L->next == NULL) return false;Linknode *s = L->next;x = s->data; L->next = s->next;free(s); return true;}

3.2. 队列

3.2.1. 队列的基本概念

1. 队列是操作受限的线性表：只允许在一端进行插入 (入队)，另一端进行删除 (出队)。
2. 队头：允许删除的一端。
3. 队尾：允许插入的一端。
4. 空队列：不含任何元素的空表。
5. 特点：先进先出（先入队的元素先出队）、FIFO（First In First Out）。

3.2.2. 队列的基本操作

1. InitQueue(&Q)：初始化队列。构造一个空队列 Q。
2. DestroyQueue(&Q)：销毁队列。销毁并释放队列 Q 所占用的内存空间。
3. EnQueue(&Q, x)：入队。若队列 Q 未满，将 x 加入，使之成为新的队尾。
4. DeQueue(&Q, &x)：出队。若队列 Q 非空，删除队头元素，并用 x 返回。
5. GetHead(Q,&x)：读队头元素。若队列 Q 非空，则将队头元素赋值给 x。
6. QueueEmpty(Q)：判空。若队列 Q 为空，则返回 true。

3.2.3. 队列的顺序存储实现

顺序队列的定义：

#define MaxSize 10; //定义队列中元素的最大个数typedef struct{ ElemType data[MaxSize]; //用静态数组存放队列元素 int front, rear;//队头指针和队尾指针}SqQueue;void test{ SqQueue Q;//声明一个队列}

顺序队列的初始化：

#define MaxSize 10;typedef struct{ ElemType data[MaxSize];int front, rear;}SqQueue;// 初始化队列void InitQueue(SqQueue &Q){// 初始化时，队头、队尾指针指向0 // 队尾指针指向的是即将插入数据的数组下标// 队头指针指向的是队头元素的数组下标Q.rear = Q.front = 0;}// 判断队列是否为空bool QueueEmpty(SqQueue Q){ if(Q.rear == Q.front)return true; elsereturn false;}

入队出队（循环队列）：

// 新元素入队bool EnQueue(SqQueue &Q, ElemType x){ // 如果队列已满直接返回if((Q.rear+1)%MaxSize == Q.front) //牺牲一个单元区分队空和队满 return false;Q.data[Q.rear] = x; Q.rear = (Q.rear+1)%MaxSize; return true;}// 出队bool DeQueue(SqQueue &Q, ElemType &x){// 如果队列为空直接返回if(Q.rear == Q.front)return false; x = Q.data[Q.front];Q.front = (Q.front+1)%MaxSize;return true;}

获得队头元素：

// 获取队头元素并存入xbool GetHead(SqQueue &Q, ElemType &x){if(Q.rear == Q.front)return false;x = Q.data[Q.front];return true;}

注意：

• 循环队列不能使用Q.rear == Q.front作为判空的条件，因为当队列已满时也符合该条件，会与判空发生冲突！

• 解决方法一：牺牲一个单元来区分队空和队满，即将(Q.rear+1)%MaxSize == Q.front作为判断队列是否已满的条件。（主流方法）

• 解决方法二：设置 size 变量记录队列长度。

  #define MaxSize 10; typedef struct{ ElemType data[MaxSize]; int front, rear;int size;}SqQueue;// 初始化队列void InitQueue(SqQueue &Q){ Q.rear = Q.front = 0; Q.size = 0;}// 判断队列是否为空bool QueueEmpty(SqQueue 0){ if(Q.size == 0)return true; else return false;}// 新元素入队bool EnQueue(SqQueue &Q, ElemType x){ if(Q.size == MaxSize)return false;Q.size++; Q.data[Q.rear] = x; Q.rear = (Q.rear+1)%MaxSize;return true;}// 出队bool DeQueue(SqQueue &Q, ElemType &x){ if(Q.size == 0)return false;Q.size--;x = Q.data[Q.front]; Q.front = (Q.front+1)%MaxSize; return true;}

• 解决方法三：设置 tag 变量记录队列最近的操作。（tag=0：最近进行的是删除操作；tag=1 ：最近进行的是插入操作）

  #define MaxSize 10; typedef struct{ElemType data[MaxSize]; int front, rear;int tag;}SqQueue;// 初始化队列void InitQueue(SqQueue &Q){Q.rear = Q.front = 0; Q.tag = 0;}// 判断队列是否为空bool QueueEmpty(SqQueue 0){if(Q.front == Q.rear && Q.tag == 0) return true; else return false;}// 新元素入队bool EnQueue(SqQueue &Q, ElemType x){if(Q.rear == Q.front && tag == 1) return false; Q.data[Q.rear] = x; Q.rear = (Q.rear+1)%MaxSize;Q.tag = 1;return true;}// 出队bool DeQueue(SqQueue &Q, ElemType &x){if(Q.rear == Q.front && tag == 0)return false; x = Q.data[Q.front];Q.front = (Q.front+1)%MaxSize; Q.tag = 0; return true;}

3.2.4. 队列的链式存储实现

链队列的定义：

// 链式队列结点typedef struct LinkNode{ElemType data;struct LinkNode *next;}// 链式队列typedef struct{ // 头指针和尾指针LinkNode *front, *rear;}LinkQueue;

链队列的初始化（带头结点）：

typedef struct LinkNode{ElemType data; struct LinkNode *next;}LinkNode;typedef struct{LinkNode *front, *rear;}LinkQueue;// 初始化队列void InitQueue(LinkQueue &Q){ // 初始化时，front、rear都指向头结点 Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));Q.front -> next = NULL;}// 判断队列是否为空bool IsEmpty(LinkQueue Q){ if(Q.front == Q.rear) return true;else return false;}

入队出队：

// 新元素入队void EnQueue(LinkQueue &Q, ElemType x){ LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode)); s->data = x;s->next = NULL; Q.rear->next = s;Q.rear = s;}// 队头元素出队bool DeQueue(LinkQueue &Q, ElemType &x){ if(Q.front == Q.rear) return false;LinkNode *p = Q.front->next; x = p->data; Q.front->next = p->next; // 如果p是最后一个结点，则将队头指针也指向NULLif(Q.rear == p)Q.rear = Q.front; free(p); return true;}

以上是带头结点的链队列，下面是不带头结点的操作：

typedef struct LinkNode{ ElemType data;struct LinkNode *next;}LinkNode;typedef struct{ LinkNode *front, *rear;}LinkQueue;// 初始化队列void InitQueue(LinkQueue &Q){ // 不带头结点的链队列初始化，头指针和尾指针都指向NULLQ.front = NULL; Q.rear = NULL;}// 判断队列是否为空bool IsEmpty(LinkQueue Q){ if(Q.front == NULL) return true;else return false;}// 新元素入队void EnQueue(LinkQueue &Q, ElemType x){ LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));s->data = x; s->next = NULL; // 第一个元素入队时需要特别处理 if(Q.front == NULL){Q.front = s;Q.rear = s; }else{Q.rear->next = s;Q.rear = s;}}//队头元素出队bool DeQueue(LinkQueue &Q, ElemType &x){if(Q.front == NULL)return false;LinkNode *s = Q.front;x = s->data;if(Q.front == Q.rear){Q.front = Q.rear = NULL;}else{Q.front = Q.front->next;}free(s);return true;}

3.2.5. 双端队列

1. 定义：

   1. 双端队列是允许从两端插入、两端删除的线性表。
   2. 如果只使用其中一端的插入、删除操作，则等同于栈。
   3. 输入受限的双端队列：允许一端插入，两端删除的线性表。
   4. 输出受限的双端队列：允许两端插入，一端删除的线性表。

2. 考点：判断输出序列的合法化

• 例：数据元素输入序列为 1，2，3，4，判断 4! = 24 个输出序列的合法性

栈中合法的序列，双端队列中一定也合法ZS

3.3. 栈与队列的应用

3.3.1 栈在括号匹配中的应用

1. 用栈实现括号匹配：
   1. 最后出现的左括号最先被匹配 （栈的特性——LIFO）。
   2. 遇到左括号就入栈。
   3. 遇到右括号，就“消耗”一个左括号（出栈）。
2. 匹配失败情况：
   1. 扫描到右括号且栈空，则该右括号单身。
   2. 扫描完所有括号后，栈非空，则该左括号单身。
   3. 左右括号不匹配。

#define MaxSize 10 typedef struct{char data[MaxSize]; int top;}SqStack;void InitStack(SqStack &S);bool StackEmpty(SqStack &S);bool Push(SqStack &S, char x);bool Pop(SqStack &S, char &x);// 判断长度为length的字符串str中的括号是否匹配bool bracketCheck(char str[], int length){ SqStack S;InitStack(S); // 遍历strfor(int i=0; i<length; i++){ // 扫描到左括号，入栈 if(str[i] == '(' || str[i] == '[' || str[i] == '{'){Push(S, str[i]);}else{// 扫描到右括号且栈空直接返回 if(StackEmpty(S))return false; char topElem;// 用topElem接收栈顶元素 Pop(S, topElem);// 括号不匹配 if(str[i] == ')' && topElem != '(' ) return false; if(str[i] == ']' && topElem != '[' )return false; if(str[i] == '}' && topElem != '{' ) return false;} }// 扫描完毕若栈空则说明字符串str中括号匹配return StackEmpty(S);}

3.3.2. 栈在表达式求值中的应用

1. 中缀表达式：中缀表达式是一种通用的算术或逻辑公式表示方法，运算符以中缀形式处于操作数的中间。对于计算机来说中缀表达式是很复杂的，因此计算表达式的值时，通常需要先将中缀表达式转换为前缀或后缀表达式，然后再进行求值。
2. 前缀表达式（波兰表达式）：前缀表达式的运算符位于两个操作数之前。
3. 后缀表达式（逆波兰表达式）：后缀表达式的运算符位于两个操作数之后。
4. 中缀转后缀的手算方法：
   1. 确定中缀表达式中各个运算符的运算顺序。
   2. 选择下一个运算符，按照==「左操作数 右操作数 运算符」==的方式组合成一个新的操作数。
   3. 如果还有运算符没被处理，就继续执行。

• 例：将 $((15÷(7-(1+1)))\times 3)-(2+(1+1))$ 转换为后缀表达式？

  答：$15711+-÷3\times 211++-$

中缀转后缀要遵循“左优先”原则：只要左边的运算符能先计算，就优先计算左边的。

5. **后缀表达式的手算方法：**从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算， 合体为一个操作数。

• 例：计算 $ABCD-\times +EF÷-$ ” />$(A+B\times (C-D))-E÷F$

6. 后缀表达式的机算方法：
   1. 从左往右扫描下一个元素，直到处理完所有元素。
   2. 若扫描到操作数则压入栈，并回到第一步；否则执行第三步。
   3. 若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到第一步。

弹出栈顶元素时，先出栈的是“右操作数”。

7. 中缀转前缀的手算方法：
   1. 确定中缀表达式中各个运算符的运算顺序。
   2. 选择下一个运算符，按照==「运算符 左操作数 右操作数」==的方式组合成一个新的操作数。
   3. 如果还有运算符没被处理，就继续执行第二步。

• 例：将 $A+B\ast (C-D)–E/F$ 转为前缀表达式？

  答：$+A-\ast B-CD/EF$

中缀转前缀遵循“右优先”原则：只要右边的运算符能先计算，就优先算右边的。

8. 前缀表达式的计算方法：

   1. 从右往左扫描下一个元素，直到处理完所有元素。
   2. 若扫描到操作数则压入栈，并回到第一步；否则执行第三步。
   3. 若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到第一步。

9. **中缀转后缀的机算方法：**初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。从左到右处理各个元素，直到末尾。可能遇到三种情况：

   1. 遇到操作数：直接加入后缀表达式。
   2. 遇到界限符：遇到“(”直接入栈；遇到“)”则依次弹出栈内运算符并加入后缀表达式，直到 弹出“(”为止。注意：“(”不加入后缀表达式。
   3. 遇到运算符：依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式， 若碰到“(” 或栈空则停止。之后再把当前运算符入栈。

   #define MaxSize 40 typedef struct{ char data[MaxSize]; int top;}SqStack;typedef struct{char data[MaxSize];int front,rear;}SqQueue;void InitStack(SqStack &S);bool StackEmpty(SqStack S);bool Push(SqStack &S, char x);bool Pop(SqStack &S, char &x);void InitQueue(SqQueue &Q);bool EnQueue(LQueue &Q, char x);bool DeQueue(LQueue &Q, char &x);bool QueueEmpty(SqQueue Q);// 判断元素ch是否入栈int JudgeEnStack(SqStack &S, char ch){char tp = S.data[S->top]; // 如果ch是a~z则返回-1if(ch >= 'a' && ch <= 'z') return -1;// 如果ch是+、-、*、/且栈顶元素优先级大于等于ch则返回0else if(ch == '+' && (tp == '+' || tp == '-' || tp == '*' || tp == '/')) return 0; else if(ch == '-' && (tp == '+' || tp == '-' || tp == '*' || tp == '/')) return 0;else if(ch == '*' && (tp == '*' || tp == '/'))return 0;else if(ch == '/' && (tp == '*' || tp == '/')) return 0;// 如果ch是右括号则返回2 else if(ch == ')')return 2; // 其他情况ch入栈，返回1 else return 1;}// 中缀表达式转后缀表达式int main(int argc, char const *argv[]) {SqStack S; SqQueue Q; InitStack(S); InitQueue(Q);char ch;printf("请输入表达式，以“#”结束：");scanf("%c", &ch); while (ch != '#'){// 当栈为空时 if(StackEmpty(&S)){ // 如果输入的是数即a~z，直接入队 if(ch >= 'a' && ch <= 'z') EnQueue(Q, ch);// 如果输入的是运算符，直接入栈elsePuch(S, ch); }else{// 当栈非空时，判断ch是否需要入栈 int n = JudgeEnStack(S, ch); // 当输入是数字时直接入队if(n == -1){EnQueue(Q, ch);}else if(n == 0){ // 当输入是运算符且运算符优先级不高于栈顶元素时while (1){ // 取栈顶元素入队char tp;Pop(S, tp);EnQueue(Q, tp); // 再次判断是否需要入栈 n = JudgeEnStack(S, ch);// 当栈头优先级低于输入运算符或者栈头为‘)’时，入栈并跳出循环if(n != 0){ EnStack(S, ch); break;} }}else if(n == 2){// 当出现‘)’时 将()中间的运算符全部出栈入队 while(1){char tp;Pop(S, tp); if(tp == '(')break;elseEnQueue(Q, tp);} }else{// 当运算符优先级高于栈顶元素或出现‘(’时直接入栈 Push(S, ch); }} scanf("%c", &ch); } // 将最后栈中剩余的运算符出栈入队 while (!StackEmpty(S)){char tp;Pop(S, tp);EnQueue(Q, tp);}// 输出队中元素 while (!QueueEmpety(Q)){printf("%c ", DeQueue(Q));}return 0;}

10. **中缀表达式的机算方法：**中缀转后缀 + 后缀表达式的求值（两个算法的结合）

• 初始化两个栈，（操作数栈和运算符栈），若扫描到操作数，压入操作数栈；若扫描到运算符或界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出一个运算符时，就需要再弹出两个操作数栈的栈顶元素并执行相应运算， 运算结果再压回操作数栈）。

3.3.3. 栈在递归中的应用

1. 函数调用的特点：最后被调用的函数最先执行结束（LIFO）。

2. 函数调用时，需要用一个“函数调用栈” 存储：

   1. 调用返回地址
   2. 实参
   3. 局部变量

3. 递归调用时，函数调用栈可称为“递归工作栈” 。每进入一层递归，就将递归调用所需信息压入栈顶；每退出一层递归，就从栈顶弹出相应信息。

4. 缺点：效率低，太多层递归可能会导致栈溢出；可能包含很多重复计算。

5. 可以自定义栈将递归算法改造成非递归算法。

3.3.4. 队列的应用

1. 树的层次遍历
2. 图的广度优先遍历
3. 操作系统中多个进程争抢着使用有限的系统资源时，先来先服务算法（First Come First Service）是是一种常用策略。

3.4. 特殊矩阵的压缩存储

除非题目特别说明，否则数组下标默认从0开始。

1. 一维数组的存储：各数组元素大小相同，且物理上连续存放。设起始地址为 LOC，则数组元素 $a[i]$ 的存放地址 = LOC + i * sizeof(ElemType) (0≤i<10)

2. 二维数组的存储：

   1. M 行 N 列的二维数组 $b[M][N]$ 中，设起始地址为 LOC，若按行优先存储，则 $b[i][j]$ 的存储地址 = LOC + (i*N + j) * sizeof(ElemType)

      

   2. M 行 N 列的二维数组 $b[M][N]$ 中，设起始地址为 LOC，若按列优先存储，则 $b[i][j]$ 的存储地址 = LOC + (j*M + i) * sizeof(ElemType)

      

3. **对称矩阵的压缩存储：**若 n 阶矩阵中任意一个元素 a i , j a_{i,j}ai,j​都有 a i , j= a j , i a_{i,j} = a_{j,i}ai,j​=aj,i​ 则该矩阵为对称矩阵。对于对称矩阵，只需存储主对角线+下三角区。若按照行优先原则将各元素存入一维数组中，即 a i , j a_{i,j}ai,j​ 存入到数组 $B[k]$ 中，那么有 k =j ( j − 1 )2+ i − 1k=\frac{j(j-1)}{2}+i-1k=2j(j−1)​+i−1 ，又 a i , j= a j , i a_{i,j}=a_{j,i}ai,j​=aj,i​ 故有：
   k= {i(i−1)2+j−1,i≥j j(j−1)2+i−1,i<j k=\left\{ \begin{array}{lr} \frac{i(i-1)}{2}+j-1, &i\geq j&\\ \frac{j(j-1)}{2}+i-1, &i< j&\\ \end{array} \right. k={2i(i−1)​+j−1,2j(j−1)​+i−1,​i≥ji<j​​

4. 三角矩阵的压缩存储：

   1. 下三角矩阵：除了主对角线和下三角区，其余的元素都相同。

   2. 上三角矩阵：除了主对角线和上三角区，其余的元素都相同。

   3. 压缩存储策略：按行优先原则将主对角线+下三角区存入一维数组中，并在最后一个位置存储常量。即 a i , j a_{i,j}ai,j​ 存入到数组 $B[k]$ 中，那么数组 $B[k]$ 共有 n ( n − 1 )2+ 1\frac{n(n-1)}{2}+12n(n−1)​+1 个元素。对于k，有：
      k= {i(i−1)2+j−1,i≥j n(n−1)2,i<j k=\left\{ \begin{array}{lr} \frac{i(i-1)}{2}+j-1, &i\geq j&\\ \frac{n(n-1)}{2}, &i< j&\\ \end{array} \right. k={2i(i−1)​+j−1,2n(n−1)​,​i≥ji<j​​

5. **三对角矩阵的压缩存储：**三对角矩阵，又称带状矩阵：当 $|i-j|>1$ 时，有 a i,j =0(1≤i,j≤n)a_{i,j} = 0 (1≤i,j ≤n) ai,j​=0(1≤i,j≤n)。对于三对角矩阵，按行优先原则，只存储带状部分，即 a i,j a_{i,j} ai,j​ 存入到数组 $B[k]$ 中，那么 $k=2i+j-3$。若已知数组下标 k，则 $i=\lfloor (k+1)/3+1\rfloor$。

6. **稀疏矩阵的压缩存储：**稀疏矩阵的非零元素远远少于矩阵元素的个数。压缩存储策略：
   1. 顺序存储：三元组
   2. 链式存储：十字链表法

四、串

4.1. 串的基本概念

1. 串：即字符串（String）是由零个或多个字符组成的有限序列。
2. 串的长度：中字符的个数 n，$n=0$ 时的串称为空串。
3. 子串：串中任意个连续的字符组成的子序列。
4. 主串：包含子串的串。
5. 字符在主串中的位置：字符在串中的序号。
6. 子串在主串中的位置：子串的第一个字符在主串中的位置 。

4.2. 串的基本操作

1. StrAssign(&T, chars)：赋值操作。把串 T 赋值为 chars。
2. StrCopy(&T, S)：复制操作。由串 S 复制得到串 T。
3. StrEmpty(S)：判空操作。若 S 为空串，则返回 TRUE，否则返回 FALSE。
4. StrLength(S)：求串长。返回串 S 中元素的个数。
5. ClearString(&S)：清空操作。将 S 清为空串。
6. DestroyString(&S)：销毁串。将串 S 销毁（回收存储空间）。
7. Concat(&T, S1, S2)：串联接。用 T 返回由 S1 和 S2 联接而成的新串 。
8. SubString(&Sub, S, pos, len)：求子串。用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串。
9. Index(S, T)：定位操作。若主串 S 中存在与串 T 值相同的子串，则返回它在主串 S 中第一次出现的位置；否则函数值为 0。
10. StrCompare(S, T)：比较操作。若 S>T，则返回值>0；若 S=T，则返回值=0；若 S<T，则返回值<0。

4.3. 串的存储实现

串的顺序存储（静态数组）：

// ch[0]废弃不用，声明int型变量length来存放串的长度#define MAXLEN 255typedef struct{char ch[MAXLEN]; int length;}SString;// 串的初始化bool InitString(SString &S){S.length = 0;return true;}// 求串的长度int StrLength(SString S){return S.length;}// 求主串由位序pos开始len长度的子串存入到串Sub中bool SubString(SString &Sub, SString S, int pos, int len){ if(pos+len-1 > S.length)return false;for(int i=pos; i<pos+len; i++)Sub.ch[i-pos+1] = S.ch[i];Sub.length = len;return true;}// 比较S与T的大小。若S>T，则返回值大于0；若S=T，则返回值等于0；若S<T，则返回值小于0int StrCompare(SString S, SString T){for(int i=1; i<=S.length && i<=T.length; i++){if(S.ch[i]!=T.ch[i]) return S.ch[i]-T.ch[i]}// 扫描过的所有字符都相同，则长度长的串更大return S.length-T.length;}// 定位串T在串S中的位置，若无法定位则返回0int Index(SString S, SString T){int i=1, n=StrLength(S), m=StrLength(T);SString sub; //用于暂存数据while(i<=n-m+1){SubString(sub, S, i, m);if(StrCompare(sub, T)!=0)++i;elsereturn i;}return 0;}void test{SString S;InitString(S);...}

串的顺序存储（动态数组）：

#define MAXLEN 255typedef struct{char *ch;int length;}HString;bool InitString(HString &S){ S.ch = (char *)malloc(MAXLEN * sizeof(char)); if(S.ch == NULL)return false;S.length = 0;return true;}void test{HString S;InitString(S);...}

串的链式存储：

typedef struct StringNode{ char ch;//每个结点存1个字符struct StringNode *next;}StringNode, *String;

上述方式存储密度很低，可以使每个结点存储多个字符。每个结点被称为块，整个链表被称为块链结构。

typedef struct StringNode{ char ch[4];//每个结点存多个字符 struct StringNode *next;}StringNode, *String;

4.4. 串的朴素模式匹配

1. 串的模式匹配：在主串中找到与模式串相同的子串，并返回其所在主串中的位置。
2. 朴素模式匹配算法思想：将主串中与模式串长度相同的子串搞出来，挨个与模式串对比。当子串与模式串某个对应字符不匹配时，就立即放弃当前子串，转而检索下一个子串。
3. 串的朴素模式匹配算法代码实现：

// 在主串S中找到与模式串T相同的子串并返回其位序，否则返回0int Index(SString S, SString T){ int k=1;int i=k, j=1;while(i<=S.length && j<=T.length){if(S.ch[i] == T.ch[j]){ ++i; ++j; }else{k++; i=k; j=1; } } if(j>T.length) return k; else return 0;}

时间复杂度：设模式串长度为m，主串长度为n

• 匹配成功的最好时间复杂度：$O(m)$
• 匹配失败的最好时间复杂度：$O(n)$
• 最坏时间复杂度：$O(nm)$

4.5. KPM算法

1. 朴素模式匹配算法的缺点：当某些子串与模式串能部分匹配时，主串的扫描指针 i 经常回溯，导致时间开销增加。最坏时间复杂度 $O(nm)$。
2. 串的前缀：包含第一个字符，且不包含最后一个字符的子串。
3. 串的后缀：包含最后一个字符，且不包含第一个字符的子串。
4. next 数组的计算方法：当第 j 个字符匹配失败时，将前（1~j-1）个字符组成的串记为S，则：==next[j]=S的最长相等前后缀长度+1。==特别地，next[1]=0。

例：求模式串“abcabd”的 next 数组。

5. KPM 算法：当子串和模式串不匹配时，主串指针 i 不回溯，模式串指针 j=next[j]。KMP 算法的平均时间复杂度为：$O(n+m)$。

6. KPM 算法代码实现：

// 获取模式串T的next[]数组void getNext(SString T, int next[]){ int i=1, j=0;next[1]=0;while(i<T.length){ if(j==0 || T.ch[1]==T.ch[j]){ ++i; ++j;next[i]=j;}elsej=next[j]; }}// KPM算法，求主串S中模式串T的位序，没有则返回0int Index_KPM(SString S, SString T){ int i=1, j=1;int next[T.length+1]; getNext(T, next);while(i<=S.length && j<=T.length){if(j==0 || S.ch[i]==T.ch[j]){ ++i; ++j; }else j=next[j]; }if(j>T.length) return i-T.length;elsereturn 0;}int main() {SString S={"ababcabcd", 9};SString T={"bcd", 3};printf("%d ", Index_KPM(S, T));//输出9}

7. KPM 算法的进一步优化：改进 next 数组：

void getNextval(SString T, int nextval[]){int i=1,j=0;nextval[1]=0;while(i<T.length){if(j==0 || T.ch[i]==T.ch[j]){++i; ++j;if(T.ch[i]!=T.ch[j])nextval[i]=j;elsenextval[i]=nextval[j];}elsej=nextval[j];}}

五、树

5.1. 树的概念

5.1.1. 树的定义和基本术语

1. 树是n（n≥0）个结点的有限集合，n = 0时，称为空树。
2. 空树中应满足：
   1. 有且仅有一个特定的称为根的结点。
   2. 当n > 1时，其余结点可分为m（m>0）个互不相交的有限集合T1，T2，…，Tm，其中每个集合本身又是一棵树，并且称为根结点的子树。
3. 度：树中一个结点的孩子个数称为该结点的度。所有结点的度的最大值是树的度。
4. 度大于0的结点称为分支结点，度为0的结点称为叶子结点。
5. 结点的层次（深度）：从上往下数。
6. 结点的高度：从下往上数。
7. 树的高度（深度）：树中结点的层数。
8. 有序树：逻辑上看，树中结点的各子树从左至右是有次序的，不能互换。
9. 若树中结点的各子树从左至右是有次序的，不能互换，则该树称为有序树，否则称为无序树。
10. 树中两个结点之间的路径是由这两个结点之间所经过的结点序列构成的，而路径长度是路径上所经过的边的个数。
11. 森林：森林是m（m≥0）棵互不相交的树的集合。

5.1.2. 树的常考性质

1. 结点数 = 总度数 + 1
2. 度为 m 的树、m 叉树的区别：

3. 度为 m 的树第 i 层至多有 m i−1 m^{i-1} mi−1 个结点（i≥1）；m 叉树第 i 层至多有 m i−1 m^{i-1} mi−1 个结点（i≥1）。

4. 高度为 h 的 m 叉树至多有 m h−1m−1 \frac{m^h-1}{m-1} m−1mh−1​ 个结点。（等比数列求和）
5. 高度为 h 的 m 叉树至少有 h 个结点；高度为 h、度为 m 的树至少有（h+m-1）个结点。
6. 具有 n 个结点的 m 叉树的最小高度为 ⌈ log⁡m(n(m−1)+1)⌉\lceil \log_{m}(n(m – 1) + 1)\rceil ⌈logm​(n(m−1)+1)⌉

5.2. 二叉树

5.2.1. 二叉树的定义

1. 二叉树是 n（n≥0）个结点的有限集合：

   1. 或者为空二叉树，即 n = 0。
   2. 或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成，左子树和右子树又分别是一棵二叉树。

2. 二叉树的特点：

   1. 每个结点至多只有两棵子树。
   2. 左右子树不能颠倒（二叉树是有序树）。

3. 二叉树的五种状态：

   1. 空二叉树
   2. 只有左子树
   3. 只有右子树
   4. 只有根节点
   5. 左右子树都有

5.2.2. 特殊二叉树

满二叉树：一棵高度为 h，且含有 2h− 12^h – 12h−1 个结点的二叉树。

特点：

1. 只有最后一层有叶子结点。
2. 不存在度为 1 的结点。
3. 若按层序从 1 开始编号，结点 i 的左孩子为 2i，右孩子为 2i+1；结点 i 的父节点为 $\lfloor i/2\rfloor$。

完全二叉树：当且仅当其每个结点都与高度为 h 的满二叉树中编号为1～n的结点一一对应时，称为完全二叉树。

特点：

1. 只有最后两层可能有叶子结点。
2. 最多只有一个度为 1 的结点。
3. 若按层序从 1 开始编号，结点 i 的左孩子为 2i，右孩子为 2i+1；结点 i 的父节点为 $\lfloor i/2\rfloor$。
4. $i\le \lfloor n/2\rfloor$ 为分支结点，$i>\lfloor n/2\rfloor$ 为叶子结点。

二叉排序树：一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树：左子树上所有结点的关键字均小于根结点的关键字；右子树上所有结点的关键字均大于根结点的关键字。

平衡二叉树：树上任一结点的左子树和右子树的深度之差不超过 1。

5.2.3. 二叉树的性质

1. 设非空二叉树中度为 0、1 和 2 的结点个数分别为 n0 n_0n0​、 n1 n_1n1​ 和 n2 n_2n2​，则 n0= n2+ 1n_0 = n_2 + 1n0​=n2​+1。

   推导过程：设树中结点总数为 n，则： n = n0+ n1+ n2 n=n_0+n_1+n_2n=n0​+n1​+n2​ ， n = n1+ 2 n2+ 1n=n_1+2n_2+1n=n1​+2n2​+1。

2. 二叉树第 i 层至多有 2 i − 1 2^{i-1}2i−1 个结点（i≥1）。

3. 高度为 h 的二叉树至多有 2h− 12^h − 12h−1 个结点（满二叉树）。

4. 具有 n 个（n>0）结点的完全二叉树的高度 h 为 ⌈ l o g2( n + 1 ) ⌉\lceil log_2(n + 1)\rceil⌈log2​(n+1)⌉ 或 ⌊ l o g2n ⌋ + 1\lfloor log_2n\rfloor + 1⌊log2​n⌋+1。

5. 对于完全二叉树，可以由总结点数 n 推出度为 0、1 和 2 的结点个数 n0 n_0n0​、 n1 n_1n1​ 和 n2 n_2n2​。

   推导过程： n1 n_1n1​ = 0 或 1， n0= n2+ 1n_0 = n_2 + 1n0​=n2​+1，则 n0+ n2 n_0 + n_2n0​+n2​ 一定是奇数。

   若完全二叉树有 $2k$（偶数）个结点，则有 n1= 1n_1=1n1​=1， n0= kn_0 = kn0​=k， n2= k − 1n_2 = k-1n2​=k−1；

   若完全二叉树有 $2k-1$（奇数）个结点，则有 n1= 0n_1=0n1​=0， n0= kn_0 = kn0​=k， n2= k − 1n_2 = k-1n2​=k−1；

5.2.4. 二叉树的实现

二叉树的顺序存储：

顺序存储完全二叉树：定义一个长度为 MaxSize 的数组 t，按照从上至下、从左至右的顺序依次存储完全二叉树中的各个结点。让第一个位置空缺，保证数组中下标和结点编号一致。

#define MaxSize 100struct TreeNode{ElemType value; //结点中的数据元素bool isEmpty;//结点是否为空}//初始化树Tbool initTree(TreeNode T[]){for(int i=0; i<MaxSize; i++){T[i].isEmpty=true; }return true;}void test(){ struct TreeNode T[MaxSize];initTree(T);}

这样可以使用二叉树的性质求一些问题：

• 结点 i 的左孩子：$2i$
• 结点 i 的右孩子：$2i+1$
• 结点 i 的父节点： $\lfloor i/2\rfloor$
• 结点 i 的层次：⌈lo g 2(i+1)⌉\lceil log_2(i + 1)\rceil ⌈log2​(i+1)⌉ 或 ⌊lo g 2i⌋+1\lfloor log_2i\rfloor + 1 ⌊log2​i⌋+1

但是如果不是完全二叉树，依然按层序将各节点顺序存储，那么将无法从结点编号反映出结点间的逻辑关系。可以将二叉树中的结点编号与完全二叉树对应起来存储，==不过这样会浪费很多内存空间。==因此，二叉树的顺序存储结构，只适合存储完全二叉树。

二叉树的链式存储：

typedef struct BiTNode{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree;//初始化bool initTree(BiTree &root){root = (BiTree)malloc(sizeof(BiTNode)); if(root == NULL) return false;root->lchild = NULL; root->rchild = NULL;return true;}void test{BiTree root = NULL; initTree(root);...}