数据结构
引用文章
在此基础上增加自己的学习过程: 《王道》数据结构笔记整理2022
1.2数据结构三要素——逻辑结构和物理结构与数据运算之间的关系
1.3抽象数据结构: 抽象数据
第一章：绪论
1.0 数据结构在学什么
- 如何使用程序代码把现实世界的问题信息化
- 如何使用计算机高效地处理这些信息从而创造价值
信息化的世界：数据结构是对数据的处理，对现实世界的数字化，生成数字文件再由操作系统完成对这些文件的管理。计算机组成原理，又是完成这一切的硬件基础。
1.1 数据结构的基本概念
- 数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。数据是计算机程序加工的原料（计算机处理的函数的入口，传递的参数）
- 数据元素：
- 数据元素是数据的基本单位，通常作为一个整体（描述现实世界的一个真实存在的个体）进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录（一个个体）就是一个数据元素，它由学号、姓名、性别等数据项组成。
- 若一个数据项由多个更细分的属性组成，则称为组合项
- 结构：各个元素之间的关系
- 数据结构：数据结构是相互之间存在一种或多种特定关系的数据元素的集合
- 数据对象：数据对象是具有相同性质的数据元素的集合，是数据的一个子集
-
数据结构与数据对象之间的关系：
- 同样的数据元素，可以根据不同的逻辑组成不同的数据结构
- 不同的数据元素，可以根据一样的逻辑组成相同的数据结构
1.2 数据结构的三要素
- 数据的逻辑结构
逻辑结构是指数据元素之间的逻辑关系，即从逻辑关系上描述数据。
- 集合结构
各个数据元素同属一个集合，别无其它关系 - 线性结构
数据元素之间是一对一关系，前驱后继（首尾除外） - 图形结构
数据元素之间是一对多的关系 - 树形结构
数据元素之间是多对多的关系
- 数据的物理结构（存储结构）
通过计算机表示数据元素的逻辑关系，存储结构是指数据结构在计算机中的表示（又称映像），也称物理结构。
存储结构：
- 顺序存储：把逻辑上相邻的元素存储在物理位置也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。
- 链式存储：逻辑上相邻的元素在物理位置上可以不相邻，借助指示元素存储地址的指针来表示元素之间的逻辑关系。
- 索引存储：在存储元素信息的同时，还建立附加的索引表，索引表中的每项称为索引项，索引项的一般形式是**（关键字，地址）**
- 散列存储：根据元素的关键字直接计算出该元素的存储地址，又称哈希（Hash）存储。
-
ps:
- 若采用顺序存储，则各个数据元素在物理上必须是连续的，若采用非顺序存储，则各个数据元素在物理上可以是离散的。
- 数据的存储结构会影响存储空间分配的方便程度，和对数据运算的速度。
-
数据的运算
施加在数据上的运算包括运算的定义和实现。
运算的定义是针对逻辑结构的，指出运算的功能；运算的实现是针对存储结构的，指出运算的具体操作步骤。 -
三要素之间的关系
1.2数据结构三要素——逻辑结构和物理结构与数据运算之间的关系
1.确定一种存储结构，就意味者在计算机中表示出数据的逻辑结构（计算机中数据结构的映射）。2.存储结构不同（例如下边的例子，顺序跟链表存储的运算方式的实现不同，但是运算方式的定义是相同的），也会导致运算的具体实现不同。
3.确定了存储结构，才能实现数据结构。
逻辑结构：
- 运算会和逻辑结构有关，和物理结构无关。
物理结构：
- 这四种结构各有优缺点：顺序虽然可以实现直接存取，但是对于空间的利用不充分；链式虽然很好利用了空间，但是得到元素只能顺序存取，这样很不方便，并且还要有额外的空间给指针；索引虽然是结合了上面两种的优缺点，但额外的索引表增加了内存损耗；散列结构不可避免会有冲突的危险。
数据运算：
- 运算包括定义和实现。运算的定义是针对逻辑结构的，运算的实现是针对存储结构的。
- 如果逻辑结构是线性的（A-B-C），物理结构是链式的（addr0[A]->addr2[B]->addr1[C]），运算的定义是找到B的前一个元素。B的前一个元素是A，但是如果实现起来，必须先找到addr0，再找addr2，确认了addr2中是B，就得到了A这个结果。但是如果这里的物理结构是顺序的，直接可以从addr0得到（B的前一个地址是addr0）。很明显两种不同的链式结构，同一种运算实现的方法是不同的。
5. 数据类型、抽象数据类型
数据类型：是一个值的集合和定义再此集合上的一组操作的总称。
- 原子类型：其值不可再分的数据类型。如bool 和int 类型。
- 结构类型：其值可以再分解为若干成分（分量）的数据类型（struct)
抽象数据类型（Abstract Data Type,ADT）：抽象数据组织及与之相关的操作。
ADT用数学化的语言定义数据的逻辑结构、定义运算。与具体的实现无关
抽象数据结构: 抽象数据
5.探讨数据结构的方式：
1.3 算法的基本概念
程序=数据结构（原料）+算法（方法步骤）
-
算法（algorithm)：是对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作。
-
算法的特性：（必要性而不是算法的定义，即不满足则不是算法，满足不一定是算法）
1.有穷性：一个算法必须总在执行有穷步之后结束，且每一步都可在有穷时间内完成。
2.确定性：算法中每条指令必须有确定的含义，对于相同的输入只能得到相同的输出。
3.可行性：算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现。
4.输入：一个算法有零个或多个输入（可以没有输入），这些输入取自于某个特定的对象的集合。
5.输出：一个算法有一个多个输出（不能没有输出），这些输出是与输入有着某种特定关系的量。 -
好的算法达到的目标：
1.正确性：算法应能够正确的求接问题。
2.可读性：算法应具有良好的可读性，以帮助人们理解。
3.健壮性：输入非法数据时，算法能适当地做出反应或进行处理，而不会产生莫名奇妙地输出结果。
4.效率与低存储量需求：效率是指算法执行的时间（时间复杂度），存储量需求是指算法执行过程中所需要的最大存储空间（空间复杂度），这两者都与问题的规模有关。
1.4 算法的时间复杂度
1.4.1 渐近时间复杂度
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，算法的时间量度记作T（n)=O(n)，它表示随问题规模n的增大而增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度。
大O表示“同阶”，同等数量级。即：当 n->∞时，二者之比为常数
1.4.2 常对幂指阶
表示图
1.4.3 时间复杂度的计算
- 顺序执行的代码只会影响常数项，可以忽略
- 挑选循环中的一个基本操作分析执行次数与n的关系即可
- 对于多层嵌套循环，只需要关注最深层的循环（嵌套最深的，即将每个循环执行次数相乘）
1.4.4 最好与最坏时间复杂度
1.5 算法的空间复杂度
1.5.1 空间复杂度
- 无论问题规模怎么变换，算法与运行所需的内存空间都是固定的常量，则空间复杂度为S(n) = O(1)
- 在计算空间复杂度时，只需关注存储空间大小与问题规模相关的变量
1.5.2 函数递归调用（未总结）
参考链接: 函数调用栈
1.5.3 存储地址
1.5.3.1 内存高低地址与高低位
大端法就是，数据的前部（对于int型就是数据的高位）存在低地址
1.5.3.2 用户程序虚拟地址空间分布
Eg：分析代码中的常量、 变量所属的段
本地编译结果
结果分析：
- i1是已经初始化的全局变量，故i存于数据段，且类型为int，四字节三十二位。
- i2是未初始化的全局变量，未设置初始值故为0（BSS段全部置零），类型为int，且由于BSS段在数据段上方，故i2（407A20）地址大于i1（403010）。
- i3是已经初始化的静态全局变量，所以i3存于数据段，类型为int，并且因为在i1之后声明，所以i3（403014）的地址高于i1（403010）的地址四个字节。
- i4是在fun（）里定义的局部变量，所以至于该函数的栈，且栈段位于最上方，所以i4的地址大于之前定义的i1 i2 i3。
- i5同i4是位于fun（）里定义的局部变量，所以i5同样位于栈段，由于栈段是向下延申的，所以i5（62FDDC）的地址小于i4（62FE00）的地址。
- i6是在fun（）里声明的静态局部变量，所以位于数据段，又因为是在i3之后声明在数据段里的所以i6（403018）地址比i3（403014）高四个字节。
- Str1是在fun（）里声明的局部指针变量char*，所以str1变量本身存放在栈段，但是变量中指向的字符串常量”ABCDE”地址，因此%P的形式打印出来的是str1（40400）所存储字符串的地址，所以打印出来的是一个位于数据段地址。又因为在i6（403018）之后声明，所以地址高于i6。
- Str2是在fun（）里声明的局部变量，所以位于栈段，且因为栈段向下延申，所以str2（62FDD0）的地址小于i5（62FDDC）的地址。
- Pi是在fun（）里声明的局部指针变量，并且为它分配了空间，指针本身位于栈段，但是它不同于str1，str1所指向的是位于数据段里的字符串”ABCDE”的地址。它指向malloc动态申请的地址空间，申请的空间位于堆段，所以%P打印出来的是位于堆段的地址，所以地址位于BSS段与栈段之间。
第二章：线性表
2.1线性表的定义（逻辑结构）
线性表是具有相同数据类型（int甚至structA自定义的结构）的n(n>0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。
所有的整数按递增次序排列，不是线性表
- n = 0时，空表
- 有限、有序、相同数据结构的元素
- a i a_i ai是线性表中的“第i个”元素线性表中的位序，位序从1开始，数组下标从0开始
- a 1 a_1 a1是表头元素， a n a_n an是表尾元素
- 除了第一和最后一个元素外，每个元素都有唯一的直接前驱以及直接后继
2.2 线性表的基本操作（运算）
注：对于传参的&L以及L两种，区别在于&L是引用型，即需要修改参数的情况既需要引用。L是仅仅获取，不进行修改返回。（引用即是对参数本身进行修改，不引用即是对参数的复制进行操作）
2.3 线性表的物理/存储结构（确定了才确定数据结构）
2.3.1 顺序表的定义
2.3.1.1 静态分配
//顺序表的实现--静态分配
#include<stdio.h>
#define MaxSize 10 //定义表的最大长度
typedef struct{
int data[MaxSize];//用静态的"数组"存放数据元素
int length; //顺序表的当前长度
}SqList; //顺序表的类型定义（静态分配方式）
void InitList(SqList &L){
for(int i=0;i<MaxSize;i++){
L.data[i]=0; //将所有数据元素设置为默认初始值
}
L.length=0;
}
int main(){
SqList L;//声明一个顺序表
InitList(L);//初始化一个顺序表
for(int i=0;i<MaxSize;i++){
printf("data[%d]=%d\n",i,L.data[i]);
}
return 0;
}
void InitList(SqList &L){
//for(int i=0;i<MaxSize;i++){
//L.data[i]=0; //将所有数据元素设置为默认初始值
//不设置数据元素的默认值
}
L.length=0;
}
会有历史遗留的脏数据，需要重新定义。对于数据初始化是编译器做的，不同的编译器可能会有脏数据也可能不会有
2.3.1.2 动态分配
//顺序表的实现——动态分配
#include<stdio.h>
#include<stdlib.h>//malloc、free函数的头文件
#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); //释放原来的内存空间
}
int main(void){
SeqList L; //声明一个顺序表
InitList(L);//初始化顺序表
IncreaseSize(L,5);
return 0;
}
2.3.1.3 malloc与free
malloc和free 基本概念及用法: link
void* malloc(size_t size);
void free(void* ptr);
-
malloc 函数用于在运行时动态分配内存。
-
malloc 接受一个 size_t 类型的参数 size，表示需要分配的内存大小（以字节为单位）。它返回一个指向分配内存起始位置的指针，或者在分配失败时返回 NULL。
-
free 函数用于释放通过 malloc 或类似函数分配的内存。
-
free 接受一个指向动态分配内存的指针 ptr，并将该内存块释放回操作系统，以便其他程序可以使用它。在释放内存后，应确保不再使用指向该内存块的指针，以避免悬挂指针的问题。
2.3.2 顺序表的特点
- 随机访问 ，可以在O(1)时间内找到第i个元素。
- 存储密度高，每个节点只存储数据元素，只存储数据本身，与链式存储（还需要存储指针）相比，存储密度高
- 拓展容量不方便（即使采用动态分配的方式实现，拓展长度的时间复杂度也比较高，增长长度之后得到了新的存储空间，新的动态分配的指针，所以需要将数据复制到新的空间）
- 插入、删除操作不方便，需要移动大量元素（顺序存储，所以删掉中间的一个需要将后边所有的元素都往前移动一个位置，增加同理）
2.3.3 顺序表的基本操作
2.3.3.1 插入操作
bool ListInsert(SqList &L, int i, int 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--){ //将第i个元素及其之后的元素后移
L.data[j]=L.data[j-1];
}
L.data[i-1]=e; //在位置i处放入e
L.length++; //长度加1
return true;
}
-
注意:
- 1.数组下标与顺序表的下标，需要加入元素的第i号位置，对应的数组的位置时i-1，所以将e的值赋值给L.data[i-1]，也就是顺序表的第i号位置（L.data[i-1]=e）
- 2.判断i的值是否有效(i<1||i>L.length+1) ，目的是防止用户在顺序表的小于1的位置插入元素（顺序表下标从1开始），并且只能在L.length+1的范围以内（当前长度+1即下一位，也不会空元素）插入元素，即元素之间不能空。
- 3.(L.length>MaxSize)，不能让顺序表的长度大于最大长度，但是可以等于
2.3.3.2 插入操作的时间复杂度
循环：for(int j=L.length; j>=i; j–)
最好情况：新元素插入表尾，i = n+1，不用移动元素 O（1）
最坏情况：新元素插入表头，i = 1，全部元素n都需要移动 O（n）
平均情况：插入每一个位置的概率都是相等的，有n +1 个位置可以插入，所以是
1
n
+
1
=
p
\frac {1} {n+1}=p
n+11=p，
n
(
n
+
1
)
2
∗
p
=
n
2
\frac{n(n+1)}{2}*p=\frac{n}{2}
2n(n+1)∗p=2n，所以O（n）
2.3.3.3 删除操作
bool LisDelete(SqList &L, int i, int &e){ // e用引用型参数 初始值可以设置位-1
//判断i的范围是否有效
if(i<1||i>L.length)
return false;
e = L.data[i-1] //将被删除的元素赋值给e
for(int j=L.length; j>=i; j--){ //将第i个后的元素前移
L.data[j-1]=L.data[j];
}
L.length--; //长度减1
return true;
}
-
注意:
- 1.e是引用类型的，所以才能返回到main函数里边，倘若不是引用类型则会赋值给内存中main函数的e的一个复制，也就是不能在main函数里打印输出，L与&L同理。
- 2.(i<1||i>L.length) 是传参i的一个合法性检验，这时的i还是不能小于1，并且最大只能跟顺序表的 length一样大，不能跟插入一样修改下一位 length+1。
2.3.3.4删除操作的时间复杂度
2.3.3.5 知识回顾与重要考点
2.3.3.6 顺序表的按位查找
#define MaxSize 10 //定义最大长度
typedef struct{
ElemType data[MaxSize]; //用静态的“数组”存放数据元素
int Length; //顺序表的当前长度
}SqList; //顺序表的类型定义
ElemType GetElem(SqList L, int i){
// ...判断i的值是否合法
if(i<1||i>L.length)
return false;
else
return L.data[i-1]; //注意是i-1
}
typedef struct{
int *data;//指示动态分配数组的指针
int MaxSize; //顺序表的最大容量
int length; //顺序表的当前长度
}SeqList;
返回的指针的类型就是我们按位查找元素时指针读取的步长，倘若不对应则会报错，不能完成读取正确的数据
2.3.3.7 顺序表按位查找的时间复杂度
2.3.3.8 顺序表按值查找
#define InitSize 10 //定义最大长度
typedef struct{
ElemTyp *data; //用静态的“数组”存放数据元素
int Length; //顺序表的当前长度
}SqList;
//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SqList L, ElemType e){
for(int i=0; i<L.lengthl i++)
if(L.data[i] == e)
return i+1; //数组下标为i的元素值等于e，返回其位序i+1
return 0; //推出循环，说明查找失败
}
基本数据类型：int float double char可以用==
结构则不能使用==判断
2.3.3.9顺序表按值查找的时间复杂度
2.3.3.10 知识回顾与重要考点
2.4 线性表的链式表示
2.4.0 引入的原因
2.4.1 单链表的定义
定义： 线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。
typedef struct LNode{//定义单链表结点类型
ElemType data; //数据域
struct LNode *next;//指针域
}LNode, *LinkList;
可以利用typedef关键字——数据类型重命名：type<数据类型><别名>
等价：
struct LNode{//定义单链表结点类型
ElemType data; //数据域
struct LNode *next;//指针域
}
typedef struct LNode LNode；
typedef struct LNode *LinkList;
2.4.2 单链表的两种实现形式
2.4.2.1 不带头结点的单链表
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){
if (L == NULL)
return true;
else
return false;
}
2.4.2.2 带头结点的单链表
头指针：开辟空间返回的指向单链表的起始物理地址的指针，仅是一个指针
不带头节点的单链表的头指针指向的头节点有数据；
带头节点的单链表的头指针指向的头节点是没有数据的
头结点：代表链表上头指针指向的第一个结点。
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//初始化一个单链表（带头结点）
bool InitList(LinkList &L){
L = (LNode*) malloc(sizeof(LNode)); //头指针指向的结点——分配一个头结点
//（不存储数据）返回的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.4.2.3知识回顾与重要考点
带头结点和不带头结点的比较：
不带头结点：写代码麻烦！对第一个数据节点和后续数据节点的处理需要用不同的代码逻辑，对空表和非空表的处理也需要用不同的代码逻辑; 头指针指向的结点用于存放实际数据;
带头结点：头指针指向的头结点不存放实际数据,头结点指向的下一个结点才存放实际数据;
2.4.3.1 带头结点的单链表按位序插入节点
ListInsert(&L, i, e) ;在表L中的第i个位置上插入指定元素e = 找到第i-1个结点(前驱结点)，将新结点插入其后；其中头结点可以看作第0个结点，故i=1时也适用。
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L, int i, ElemType e){
//判断i的合法性, i是位序号(从1开始)
if(i<1)
return False;
LNode *p; //指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点，=0则表示目前指向头节点，链表下标从1开始
p = L; //L指向头结点，头结点是第0个结点（不存数据）
//循环找到第i-1个结点，因为要修改插入节点位子的前一个节点的指针
while(p!=NULL && j<i-1){ //如果i>lengh, p最后会等于NULL
p = p->next; //p指向下一个结点
j++;
}
if (p==NULL) //i值不合法
return false;
//在第i-1个结点后插入新结点
LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点空间用于存放新的节点的数据
s->data = e; //让新的节点的数据为e
s->next = p->next; //让新的节点的
p->next = s; //将结点s连到p后,后两步千万不能颠倒qwq
return true;
}
-
注意:
- 1.j = 0,是头节点的位置，这个0是方便编程的，链表的下标是从1开始
- 2.需要找到的位置是i-1，因为需要修改插入节点位置的上一个LNode的指针，让它指向插入节点
- 3.倘若最后查找出来的p指针指向null，则说明i的值不合法，因为第i-1个元素已经是null了，超过了最后一个节点，指向了null
- 4.最重要的LNode的指针逻辑：首先申请一个新的LNode地址指针，指向新分配的空间；设置这个LNode的数据值为e；新分配的LNode的下一个位置指向p的下一个位置（绿色线）；再将当前的p指针的下一位指向新分配的LNode（黄色线）。
- 5.倘若绿色黄色颠倒，则会产生LNode指向自己而不是原本的p指向的后边的链表，后边的链表就会丢失。
2.4.3.2 单链表的插入节点的时间复杂度
最好情况：插入表头 O（1）
最坏情况：插入表尾O（n）
平均时间复杂度：O（n）
插入每个位置（n+1个位置）的概率都是
1
n
+
1
\frac{1}{n+1}
n+11，
(
1
+
n
)
n
2
∗
1
n
+
1
=
n
2
\frac{(1+n)n}{2}*\frac{1}{n+1} =\frac{n}{2}
2(1+n)n∗n+11=2n
2.4.3.3 不带头结点的单链表的插入节点
ListInsert(&L, i, e) :在表L中的第i个位置上插入指定元素e = 找到第i-1个结点(前驱结点)，将新结点插入其后; 因为不带头结点，所以不存在“第0个”结点，因此！i=1 时，需要特殊处理——插入(删除)第1个元素时，需要更改头指针L;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L, int i, ElemType e){
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;
int j=1;
p = L; //L指向第一个结点（存数据）
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ //如果i>lengh, p最后会等于NULL
p = p->next; //p指向下一个结点
j++;
}
if (p==NULL) //i值不合法
return false;
//在第i-1个结点后插入新结点
LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
-
注意:
- 1.最重要的LNode的i = 1的指针逻辑：首先申请一个新的LNode地址指针，指向新分配的空间；设置这个LNode的数据值为e；新分配的LNode的下一个位置指向头指针L指向的位置（s->next =L; 绿色线）；再将当前的头指针L指向新分配的LNode（L=s; 黄色线）。
- 2.不带头节点插入删除i=1的节点，需要修改头指针，所以不带头指针需要考虑对i=1操作的情况会比较麻烦。
- 3.此时对于定位的j，需要设置初始值为1，而不是带头节点的0。
- 4.若i不为1，则操作都一样
2.4.3.4 不带头结点的单链表的插入节点的时间复杂度
同上
最好情况：插入表头 O（1）
最坏情况：插入表尾O（n）
平均时间复杂度：O（n）
插入每个位置（n+1个位置）的概率都是
1
n
+
1
\frac{1}{n+1}
n+11，
(
1
+
n
)
n
2
∗
1
n
+
1
=
n
2
\frac{(1+n)n}{2}*\frac{1}{n+1} =\frac{n}{2}
2(1+n)n∗n+11=2n
2.4.3.5 指定节点的后插操作
InsertNextNode(LNode *p, ElemType e): 给定一个结点p，在其之后插入元素e; 根据单链表的链接指针只能往后查找，故给定一个结点p，那么p之后的结点我们都可知，但是p结点之前的结点无法得知;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
bool 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保存数据元素e
s->next = p->next;
p->next = s; //将结点s连到p之后
return true;
} //平均时间复杂度 = O(1)
//有了后插操作，那么在第i个位置上插入指定元素e的代码可以改成：
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1)
return False;
LNode *p; //指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点（不存数据）
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ //如果i>lengh, p最后4鸟会等于NULL
p = p->next; //p指向下一个结点
j++;
}
return InsertNextNode(p, e)
}
-
注意:
- 1.bool InsertNextNode(LNode *p, ElemType e)，后插操作判断给的指针是否是空指针；判断是否内存分配失败
- 2.找到第i-1个节点就可以调用这个后插函数 return InsertNextNode(p, e)
- 3.时间复杂度为O（1）
if(p==NULL){
return false;
}
LNode *s = (LNode *)malloc(sizeof(LNode));
//某些情况下分配失败，比如内存不足
if(s==NULL)
return false;
2.4.3.6 指定节点的前插操作
InsertPriorNode(LNode *p, ElenType e) 思想：设待插入结点是s，将s插入到p的前面。我们仍然可以将s插入到*p的后面。然后将p->data与s->data交换，这样既能满足了逻辑关系，又能是的时间复杂度为O(1).
-
传入头指针，从头开始遍历寻找到指定节点前驱
-
不传入头节点，使用交换指定节点和需要插入节点的数据，完成操作
该方法时间复杂度为O（1)
//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p, ElenType e){
if(p==NULL)
return false;
LNode *s = (LNode *)malloc(sizeof(LNode));
if(s==NULL) //内存分配失败
return false;
//重点来了！
s->next = p->next;
p->next = s; //新结点s连到p之后
s->data = p->data; //将p中元素复制到s
p->data = e; //p中元素覆盖为e
return true；
} //时间复杂度为O(1)
- 王道书上版本（传入指定节点与需要插入的节点）
bool InsertPriorNode(LNode *p, LNode *s){
if(p==NULL || S==NULL)
return false;
s->next = p->next;
p->next = s; ///s连接到p
ELemType temp = p->data; //声明临时变量temp存储p的数据
p->data = s->data; //用需要插入节点的数据覆盖p中的数据
s->data = temp; //将临时变量赋值给s的数据部分
return true;
}
ELemType temp = p->data; //交换数据域部分，声明临时变量temp存储p的数据
2.4.3.7 按位序删除节点（带头结点）
ListDelete(&L, i, &e) : 删除操作，删除表L中第i个位置的元素，并用e返回删除元素的值;头结点视为“第0个”结点；
思路：找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点；
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
bool ListDelete(LinkList &L, int i, ElenType &e){
if(i<1) return false;
LNode *p; //指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点（不存数据）
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ //如果i>lengh, p最后会等于NULL
p = p->next; //p指向下一个结点
j++;
}
if(p==NULL)
return false;
if(p->next == NULL) //第i-1个结点之后已无其他结点
return false;
LNode *q = p->next; //令q指向被删除的结点
e = q->data; //用e返回被删除元素的值
p->next = q->next; //将*q结点从链中“断开”
free(q) //释放结点的存储空间
return true;
}
2.4.3.8 按位序删除节点（带头结点）的时间复杂度
同上
最好情况：插入表头 O（1）
最坏情况：插入表尾O（n）
平均时间复杂度：O（n）
2.4.3.9 指定结点的删除
bool DeleteNode(LNode *p){
if(p==NULL)
return false;
LNode *q = p->next; //令q指向*p的后继结点
p->data = p->next->data; //让p和后继结点交换数据域
p->next = q->next; //将*q结点从链中“断开”
free(q);
return true;
} //时间复杂度 = O(1)
倘若需要删除的是最后一个节点，则时间复杂度为O（n），因为找不到下一个节点不能跟它交换数据，再free它。只能从链表的头开始寻找到该指针的前继节点，将它指向null。
2.4.3.10 知识回顾与重要考点
2.4.4单链表的查找操作（默认带头节点，不带头节点后续更新）
2.4.4.1 按位查找操作
GetElem(L, i): 按位查找操作，获取表L中第i个位置的元素的值;
LNode * GetElem(LinkList L, int i){
if(i<0) return NULL;
LNode *p; //指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p = L; //L指向头结点,头结点是第0个结点(不存数据)
while(p!=NULL && j<i){ //循环找到第i个结点
p = p->next;
j++;
}
return p; //返回p指针指向的值
}
-
注意：
- 1.边界情况 i=0，返回头节点；i>L.length，返回null；
- 2.j<i即查找到j = i 的节点，就是第i个节点。
- 3.平均复杂度O（n）
2.4.4.2 按值查找操作
LocateElem(L, e):按值查找操作，在表L中查找具有给定关键字值的元素;
平均复杂度O（n）
LNode * LocateElem(LinkList L, ElemType e){
LNode *P = L->next; //p指向第一个结点
//从第一个结点开始查找数据域为e的结点
while(p!=NULL && p->data != e){
p = p->next;
}
return p; //找到后返回该结点指针，否则返回NULL
}
2.4.4.3 求单链表的长度（带和不带头节点都写了）
Length(LinkList L) ：计算单链表中数据结点**（不含头结点）的个数**，需要从第一个结点看是顺序依次访问表中的每个结点。算法的时间复杂度为O（n）。
带头节点：
int Length(LinkList L){
int len=0; //统计表长
LNode *p = L;
while(p->next != NULL){ //只有指向的下一个节点不为null，才len++
p = p->next;
len++;
}
return len;
}
不带头节点：
int Length(LinkList L){
int len=0; //统计表长
LNode *p = L;
while(p!= NULL){ //当前指针(即头节点指向的第一个节点)不为空即可++，
//带头节点的链表用这种方法长度会算上头节点。
p = p->next;
len++;
}
return len;
}
2.4.4.4 知识回顾与重要考点
2.4.5 单链表的创建操作
2.4.5.1 头插法建立单链表
带头节点；
若不带头节点，头插法就是插入头指针指向的第一个节点
平均时间复杂度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;
}
2.4.5.2 尾插法建立单链表
带头节点；
若不带头节点则需要特殊处理第一次插入数据的情况，是直接赋值而不是对下一个节点赋值。
时间复杂度O（n）
思路：每次将新节点插入到当前链表的表尾，所以必须增加一个尾指针r,使其始终指向当前链表的尾结点。
好处：生成的链表中结点的次序和输入数据的顺序会一致。
LinkList List_TailInsert(LinkList &L){ //正向建立单链表
int x; //设ElemType为整型int
L = (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;
}
-
注意：
- 头插法和尾插法在初始化的时候
头插法：
L = (LinkList)malloc(sizeof(LNode)); //建立头结点
L->next = NULL; //初始为空链表,这步不能少！
尾插法：
L = (LinkList)malloc(sizeof(LNode)); //建立头结点(初始化空表)
r->next = NULL; //尾结点指针置空
都是为了保证最后一个节点指向的不是脏数据，即malloc动态分配空间的时候可能，
指向的是一个脏数据
2.4.5.3 链表的逆置
算法思想：逆置链表初始为空，原表中结点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空；
带头节点：
void listReverse(linkedList &L)
{
node *p,*s;
//1.准备工作
p = L->next;
L->next = NULL;
while(p)
{
//2.1 s记录正在处理的结点，p记录下一轮待处理的结点
s = p; //s承接上一轮记录的位置
p = p->next; //p为下一轮记录位置
//2.2 把s插入 已逆置的部分 中
s->next = L->next; // L->next代表已逆置的第一结点，s的指针域指向它
L->next = s; //（头结点的指针域，即）第一结点 设置为s
//2.2步骤相当于：
//s 对 队伍（已逆置部分）的队首（已逆置的第一结点）说：你不要排在柜台前了，你排在我后面
//等队伍排在s后面后，s自己排到了柜台前
}
}
讲解
我们先看第一轮循环做了什么：
阅读顺序：黑色（初始）、蓝色（操作）、红色（理解）
第二轮：
阅读顺序：黑色（初始）、蓝色（操作）、红色（理解）
总结
不难发现：
-
链表逆置利用了s、p两个指针的移动实现
每一轮循环体执行结束后，s指向刚刚逆置成功的结点，p指向下一轮待逆置的结点 -
为什么需要p？
因为2.2步骤中s->next会被改写，
若只有s，会丢失剩余的结点，
这时候p起到暂存的作用，等待下一轮2.1步骤中的s=p找到它。
2.4.6 双链表
2.4.6.1 双链表中节点类型的描述：
typedef struct DNode{ //定义双链表结点类型
ElemType data; //数据域
struct DNode *prior, *next; //前驱和后继指针
}DNode, *DLinklist;
存储密度更低，因为需要额外空间存储前驱指针
2.4.6.2 双链表的初始化
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; // 定义指向头结点的指针L
InitDLinkList(L); //申请一片空间用于存放头结点，指针L指向这个头结点
//...
}
//判断双链表是否为空
bool Empty(DLinklist L){
if(L->next == NULL) //判断头结点的next指针是否为空
return true;
else
return false;
}
2.4.6.3 双链表的插入操作
- 后插操作
InsertNextDNode(p, s): 在p结点后插入s结点 - 按位序插入操作：
思路：从头结点开始，找到某个位序的前驱结点，对该前驱结点执行后插操作； - 前插操作：
思路：找到给定结点的前驱结点，再对该前驱结点执行后插操作；
bool InsertNextDNode(DNode *p, DNode *s){ //将结点 *s 插入到结点 *p之后
if(p==NULL || s==NULL) //非法参数
return false;
s->next = p->next; //1
if (p->next != NULL) //p不是最后一个结点=p有后继结点
p->next->prior = s; //2
s->prior = p; //3
p->next = s; //4
return true;
}
2.4.6.4 双链表的删除操作
删除p节点的后继节点 （遍历实现）
//删除p结点的后继结点
bool DeletNextDNode(DNode *p){
if(p==NULL) return false;
DNode *q =p->next; //找到p的后继结点q
if(q==NULL) return false; //p没有后继结点;
p->next = q->next;
if(q->next != NULL) //q结点不是最后一个结点
q->next->prior=p;
free(q);
return true;
}
//销毁一个双链表
bool DestoryList(DLinklist &L){
//循环释放各个数据结点
while(L->next != NULL){
DeletNextDNode(L); //删除头结点的后继结点
free(L); //释放头结点
L=NULL; //头指针指向NULL
}
}
2.4.6.5 双链表的遍历操作
前向遍历
while(p!=NULL){
//对结点p做相应处理，eg打印
p = p->prior;
}
后向遍历
while(p!=NULL){
//对结点p做相应处理，eg打印
p = p->next;
}
2.4.6.6 知识回顾与重要考点
2.4.7 循环链表
2.4.7.1 循环单链表
最后一个结点的指针不是NULL,而是指向头结点
L->next = L; //头结点next指针指向头结点
L->next == L ; //判空
p->next == L ; //判断是否是尾节点
typedef struct LNode{
ElemType data;
struct LNode *next;
}DNode, *Linklist;
/初始化一个循环单链表
bool InitList(LinkList &L){
L = (LNode *)malloc(sizeof(LNode)); //分配一个头结点
if(L==NULL) //内存不足，分配失败
return false;
L->next = L; //头结点next指针指向头结点
return true;
}
//判断循环单链表是否为空（终止条件为p或p->next是否等于头指针）
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;
else
return false;
}
2.4.7.2 单链表和循环单链表的比较：
单链表：从一个结点出发只能找到该结点后续的各个结点；对链表的操作大多都在头部或者尾部；设立头指针，从头结点找到尾部的时间复杂度O(n)，即对表尾进行操作需要O(n)的时间复杂度;
循环单链表：从一个结点出发，可以找到其他任何一个结点；设立尾指针，从尾部找到头部的时间复杂度为O(1)，即对表头和表尾进行操作都只需要O(1)的时间复杂度;
优点:从表中任一节点出发均可找到表中其他结点。
2.4.7.3 循环双链表
表头结点的prior指向表尾结点，表尾结点的next指向头结点
L->prior = L; //头结点的prior指向头结点
L->next = L; //头结点的next指向头结点
L->next == L //判空
p->next == L //判断是否为表尾
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 = L; //头结点的prior指向头结点
L->next = L; //头结点的next指向头结点
}
void testDLinkList(){
//初始化循环单链表
DLinklist L;
InitDLinkList(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;
else
return false;
}
双链表的插入（循环双链表）：
不同于双链表的的操作，循环双链表的插入操作不需要判断 p->next->prior = s;这一步的 p->next->prior 是否存在，即p的下一个节点是不是null。
bool InsertNextDNode(DNode *p, DNode *s){
s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;
双链表的删除
同理 q->next->prior
//删除p的后继结点q
p->next = q->next;
q->next->prior = p;
free(q);
2.4.7.4 知识回顾与重要考点
2.4.8 静态链表
- 定义：
单链表：各个结点散落在内存中的各个角落，每个结点有指向下一个节点的指针(下一个结点在内存中的地址);
静态链表：用数组的方式来描述线性表的链式存储结构: 分配一整片连续的内存空间，各个结点集中安置，包括了——数据元素and下一个结点的数组下标(游标)
其中数组下标为0的结点充当"头结点"
游标为-1表示已经到达表尾
游标为-2表示该位置为空，没有数据且没有游标指向这个位置
若每个数据元素为4B，每个游标为4B，则每个结点共8B；假设起始地址为addr，则数据下标为2的存放地址为：addr+8*2
注意： 数组下标——物理顺序，位序——逻辑顺序；
优点：增、删操作不需要大量移动元素；
缺点：不能随机存取，只能从头结点开始依次往后查找，容量固定不变！
-
几种写法：
注意：SLinkList a 强调a是静态链表；struct Node a 强调a是一个Node型数组；
-
静态链表基本操作的实现
-
初始化静态链表：把a[0]的next设为-1
-
查找某个位序（不是数组下标，位序是各个结点在逻辑上的顺序）的结点：从头结点出发挨个往后遍历结点，时间复杂度O=(n)
-
在位序为i上插入结点：① 找到一个空的结点，存入数据元素；② 从头结点出发找到位序为i-1的结点；③修改新结点的next；④ 修改i-1号结点的next；
-
删除某个结点：① 从头结点出发找到前驱结点；② 修改前驱节点的游标；③ 被删除节点next设为-2；
2.4.9 顺序表和链表的比较
2.4.9.1 逻辑结构
- 顺序表和链表都属于线性表，都是线性结构
2.4.9.2 存储结构
-
顺序表：顺序存储
优点：支持随机存取，存储密度高
缺点：大片连续空间分配不方便，改变容量不方便 -
链表：链式存储
优点：离散的小空间分配方便，改变容量方便
缺点：不可随机存取，存储密度低
2.4.9.3 基本操作 - 创建
-
顺序表：需要预分配大片连续空间。若分配空间过小，则之后不方便拓展容量；若分配空间过大，则浪费内存资源；
-
静态分配：静态数组，容量不可改变
-
动态分配：动态数组，容量可以改变，但是需要移动大量元素，时间代价高（malloc(),free()）
-
链表：只需要分配一个头结点或者只声明一个头指针
2.4.9.4 基本操作 - 销毁
顺序表：
首先修改 Length = 0
- 静态数组——系统自动回收空间
typedef struct{
ElemType *data;
int MaxSize;
int length;
}SeqList;
创建的时候静态建立没有malloc分配空间。
- 动态分配：动态数组——需要手动free()，一个malloc对应一个free，成对出现
//创
L.data = (ELemType *)malloc(sizeof(ElemType) *InitSize)
//销
free(L.data);
//！malloc() 和 free() 必须成对出现
2.4.9.5 基本操作-增/删
-
顺序表：插入/删除元素要将后续元素后移/前移；时间复杂度=O(n)，时间开销主要来自于移动元素；
-
链表：插入/删除元素只需要修改指针；时间复杂度=O(n)，时间开销主要来自查找目标元素
需要注意的是：在单个元素占用空间很大的情况下，顺序表增删元素的时间开销很大（因为主要的时间开销不在查找元素而是在移动元素，并且移动的元素很大），而链表的时间开销仍能保持在一个较小的数值（因为链表主要的时间开销在于移动指针寻找节点，所以才节点大小很大的时候仍能保证一定的速度）。
此时时间开销他们二者虽然都是O（n）但是在面对较多的增删操作的情况下一般会选择链表实现。
2.4.9.6 基本操作-查
-
顺序表
按位查找：O(1)
按值查找：O(n)，若表内元素有序，可在O(log2n)时间内找到 -
链表
按位查找：O(n)
按值查找：O(n)
2.4.9.7 顺序、链式、静态、动态四种存储方式的比较
- 顺序存储的固有特点：
逻辑顺序与物理顺序一直，本质上是用数组存储线性表的各个元素（即随机存取）；存储密度大，存储空间利用率高。 - 链式存储的固有特点：
元素之间的关系采用这些元素所在的节点的“指针”信息表示（插、删不需要移动节点）。 - 静态存储的固有特点：
在程序运行的过程中不要考虑追加内存的分配问题。 - 动态存储的固有特点：
可动态分配内存；有效的利用内存资源，使程序具有可扩展性。
2.4.9.8 存储密度的问题
-
存储密度：
在数据结构中，结点数据本身所占的存储量和整个结点结构所占的存储量之比。
存储密度 = 结点数据本身所占存储量 / 整个结点结构所占的存储量 -
顺序表的存储密度等于1
-
单链表的存储密度小于1
-
假设单链表的结点的数据占的存储量为N，结点的指针域所占的存储量为M，则存储密度 = N / (N+M)，所以单链表的密度是小于1的。
2.4.9.9 存储方式的选择以及二者优劣的答题思路（综述优劣，细谈情况）
2128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
