diff --git a/.DS_Store b/.DS_Store index df68f69..22e639c 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/数据结构/.DS_Store b/数据结构/.DS_Store index b23898b..dcf3b63 100644 Binary files a/数据结构/.DS_Store and b/数据结构/.DS_Store differ diff --git a/数据结构/思维导图/.DS_Store b/数据结构/思维导图/.DS_Store new file mode 100644 index 0000000..048e15b Binary files /dev/null and b/数据结构/思维导图/.DS_Store differ diff --git a/数据结构/思维导图/基础入门.xmind b/数据结构/思维导图/基础入门.xmind new file mode 100644 index 0000000..8676310 Binary files /dev/null and b/数据结构/思维导图/基础入门.xmind differ diff --git a/数据结构/思维导图/线性表.xmind b/数据结构/思维导图/线性表.xmind new file mode 100644 index 0000000..520cd2e Binary files /dev/null and b/数据结构/思维导图/线性表.xmind differ diff --git a/数据结构/数据结构.xmind b/数据结构/数据结构.xmind index 7126ca5..ea79fa3 100644 Binary files a/数据结构/数据结构.xmind and b/数据结构/数据结构.xmind differ diff --git a/数据结构/线性表/.DS_Store b/数据结构/线性表/.DS_Store new file mode 100644 index 0000000..41c6ecf Binary files /dev/null and b/数据结构/线性表/.DS_Store differ diff --git a/数据结构/线性表/1.基础概念和基本操作.md b/数据结构/线性表/1.基础概念和基本操作.md new file mode 100644 index 0000000..90fd4b4 --- /dev/null +++ b/数据结构/线性表/1.基础概念和基本操作.md @@ -0,0 +1,61 @@ + + + + +## 线性表的基础概念和基本操作 + +> 强调线性表是一种逻辑结构，不是存储结构 + + +### 定义 + +线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列。一般表示： + +L=(a1,a2,a3......an) 其中n可以理解为表长（线性表的长度），n=0时候，即表空 + + +- `表头元素`：线性表中唯一的“第一个”数据元素，例如a1 +- `表尾元素`：线性表中唯一的“最后一个”数据元素，例如an + + +重要逻辑特性： + +- 除表头元素外，线性表中每个元素有且仅有一个`直接前驱` +- 除表尾元素外，线性表中每个元素有且仅有一个`直接后继` + +基于此，这种**线性有序的逻辑结构**,使得线性表的特点如下： + +- 元素的**个数有限**（强调有限序列） +- 元素在逻辑上具有**顺序性**，在序列中每个元素都是都有先后次序的 +- 元素都数据元素，**每个元素都是单个元素** +- 元素的**数据类型都相同**（强调相同数据类型），每个数据元素占用相同大小的存储空间 +- 元素具有**抽象性**，仅仅讨论元素之间的逻辑关系，不需要去考虑元素究竟表示的什么内容 + + +> Tips: **线性表是一种逻辑结构**，表示元素之间一对一的相邻关系。**顺序表和链表则指的是存储结构** + + + +### 基本操作 + +- `InitList(&L)`： **初始化表**。构造空的线性表 +- `Length(L)`：**获取表的长度**。返回线性表L的长度，即表中的数据元素个数 +- `LocateElem(L,e)`：**按值查找操作**。在表L中国查找具有给定关键字的元素 +- `GetElem(L,i)`：**按位查找操作**。获取表中第i个位置的元素的值 +- `ListInsert(&L,i,e)`：**插入操作**。在表的第i个位置上插入指定元素e +- `ListDelete(&L,i,&e)`：**删除操作**。删除表中第i个位置的元素，并用e返回删除元素的值 +- `PrintList(L)`：**输出操作**。按照前后顺序（如：1、2....n）输出线性表的所有元素值 +- `Empty(L)`：**判空操作**。当表L为空，则返回true，否则返回false +- `DestoryList(&L)`：**销毁操作**。将线性表销毁，释放线性表L所占用的内存空间（类似：释放内存） + + +线性表是具有相同的数据类型的有限个数据元素组成的，**数据元素是由数据项组成的** + + diff --git a/数据结构/线性表/2.线性表的顺序表示.md b/数据结构/线性表/2.线性表的顺序表示.md new file mode 100644 index 0000000..0a3f570 --- /dev/null +++ b/数据结构/线性表/2.线性表的顺序表示.md @@ -0,0 +1,274 @@ + + + +## 线性表的顺序表示 + + +### 定义 + +`顺序表`：顺序存储的线性表，**是用一组地址连续的存储单元，依次存储线性表中的数据元素，使得在逻辑上相邻的两个元素在物理位置上也相邻。** + + + + + + +顺序表中的元素的逻辑顺序与实际的物理位置相同 + + + +注意： + +- 线性表中的元素的位序是从1开始的，例如1、2、3... +- 数组中的元素的下标是从0开始的，例如0、1、2... + +```c +# define MaxSize 20 // 定义常量MaxSize 用来声明顺序表的最大长度 + +// 线性表结构体定义【ElemType用来代指顺序表中元素的类型，例如高级语言中的int、string....】 +typedef struct{ + ElemType data[MaxSize]; // 顺序表的元素 + int length; // 顺序表的长度 +}SqList + +``` + +#### 存储分配 + +`静态分配`：数组的大小和空间都是实现确定好的，一旦存储空间占满就会产生溢出，直接导致程序崩溃。（有点内存不够，宕机重启的意思....） + +`动态分配`：存储数据的空间在程序执行过程中通过`动态存储分配语句`分配的，即便是数据空间占满，也可以另外开辟一块更大的空间，来替换原来的存储空间，满足扩充数据空间的目的。（有点动态规划的意思....）最重要的是：**不需要像静态分配那样，一次性地固定线性表的空间和大小** + + + +```c +#define InitSize 100 // 表长度初始化 + + +// 动态分配数组顺序表的结构体定义 +typedef struct{ + ElemType *data; // 动态分配数组的指针 + int MaxSize,length; // 数组的最大容量和当前元素个数 +}SqList; + +``` + +动态分配语句 + +```C +// C语言中 + +L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize); + + +// C++ 中 + +L.data=new ElemType[InitSize]; + +``` + +`malloc()函数`： 指针型函数，返回的指针指向该分配域的开头的位置。作用是在内存的动态存储区中分配一个长度为size的连续空间。[百度百科](https://baike.baidu.com/item/malloc%E5%87%BD%E6%95%B0/8582146?fr=aladdin) + +**动态分配不是链式存储，而是属于顺序存储结构**，动态分配的物理结构没有改变，依然是随机存取的方式。只是分配的空间大小可以在运行时决定； + + +#### 顺序表的特点 + + +- 随机访问【这是最主要的特点】，通过存储起始地址和元素序号O(1)时间内访问指定元素。 +- 存储密度高，没有结点只存储数据元素，不像索引存储那样，还需要索引表什么的.. +- 逻辑上相邻的元素物理上也相邻，插入和删除需要移动大量元素 + + + + + +### 基本操作 + + +#### 插入 + +在顺序表L的第i（1≤i≤L.length+1）个位置插入新的元素e + +- 第一步：如果i非法，则直接返回false，插入失败，结束插入过程 +- 第二步：i正常，将表的第i个元素以及后面的所有元素都像有移动一个位置，在腾出来的空位置插入元素e +- 第三步：顺序表插入成功，返回true + +注意：先判空和临界值，提高算法健壮性 + +```C++ + +/* + * @Description: 顺序表的插入操作 + * @Version: Beta1.0 + * @Author: 【B站&公众号】Rong姐姐好可爱 + * @Date: 2020-02-23 07:48:26 + * @LastEditors: 【B站&公众号】Rong姐姐好可爱 + * @LastEditTime: 2020-02-23 07:48:26 + */ +bool ListInsert(SqList &L, int i, ElemType e){ + + // i非法 i=1 表头 i=L.length+1 表尾巴 + if(i<1||i>L.length+1){ + return false; + } + + // 存储空间满，无法插入 + if(L.length >= MaxSize){ + return false; + } + + // 遍历，将位置元素往后移动，注意从后往前循环，避免值被覆盖 + for(int j=L.length; j>=i;j--){ + L.data[j]=L.data[j-1]; + } + + // 此时，表L中的第i个元素和第i+1元素素值一样，将新元素存入i位置即可 + + // 第i个元素，对应的位置角标为i-1 + L.data[i-1]=e; + + // 表长度加1 + L.length++; + + // 返回插入成功 + return true; +} + +``` + +注意：区别顺序表中的位序和角标； + +**时间复杂度** + +- 最好情况：在表尾插入，元素向后移动循环没有执行，时间复杂度O(1); +- 最坏情况：在表头插入，元素后移循环执行n次，时间复杂度为O(n); +- 平均情况：随机插入，平均次数为：n/2，对应的平均复杂度为O(n); + + +**线性表插入算法的平均时间复杂度为：O(n)** + +> Tips: 需要根据实现代码理解循环为什么是从后往前来实现元素后移，通过for循环可以很明显的看出表尾插入快，表头插入慢 + +#### 删除 + +删除顺序表L中第i（1≤i≤L.length+1）个位置的元素 + +- 成功，返回true,将被删除的元素用引用变量返回； +- 失败，返回false + +```C++ + +/* + * @Description: 顺序表的删除操作 + * @Version: Beta1.0 + * @Author: 【B站&公众号】Rong姐姐好可爱 + * @Date: 2020-02-23 07:48:26 + * @LastEditors: 【B站&公众号】Rong姐姐好可爱 + * @LastEditTime: 2020-02-23 07:48:26 + */ +bool ListDelete(SqList &L, int i, ElemType &e){ + + // i非法 i=1 表头 i=L.length+1 表尾巴 + if(i<1||i>L.length+1){ + return false; + } + + // 存储空间满，无法插入 + if(L.length >= MaxSize){ + return false; + } + + // 引用变量e赋值 + e=L.data[i-1] + + // 遍历，第i个元素后面的往前移动 + for(int j=i; j<=L.length;j++){ + // 从第i个元素开始，角标从i-1开始 + L.data[j-1]=L.data[j]; + } + + // 此时，表L中的表尾元素和倒数第二个元素值一样，将表的长度-1 + + // 表长度减1 + L.length--; + + // 返回删除成功 + return true; +} + +``` + +从这里来看，删除、插入元素都会涉及到大量的元素的移动（最好情况例外），总结而言： +- 元素从后往前移，循环从前往后遍历 +- 元素从前往后移，循环从后往前遍历 + + +**时间复杂度：** + + +- 最好情况：删除表尾元素，不需要移动任何元素，时间复杂度为O(1)； +- 最坏情况：删除表头元素，需要移动除第一个元素外的所有元素，时间复杂度为O(n)； +- 平均情况：随机删除，平均需要(n-1)/2，对应的时间复杂度为O(n)； + + + +**线性表删除算法的平均时间复杂度为O(n)；** + + +#### 按值查找（顺序查找） + +在顺序表L中查找第一个元素值等于e的元素，并返回位序 + + +```C++ +/* + * @Description: 顺序表的按值查找（顺序查找） + * @Version: Beta1.0 + * @Author: 【B站&公众号】Rong姐姐好可爱 + * @Date: 2020-02-23 07:48:26 + * @LastEditors: 【B站&公众号】Rong姐姐好可爱 + * @LastEditTime: 2020-02-23 07:48:26 + */ +int LocateElem(SqList L,ElemType e){ + int i; + // 循环判断 + for(i=0;i + + + + +## 线性表的链式表示 + +顺序表的插入、删除操作需要移动大量元素，影响了运行效率（虽然时间复杂度为O(1)的情况也存在）。 + + +**链式存储线性表时，不需要使用连续的存储单元，不要求逻辑上相邻的两个元素在物理位置上也相邻** + + +理解“链”的含义，链条--->捆绑、指向------>指针 + + +**链式存储线性表时，对线性表的插入、删除元素是不需要移动元素的，只是需要修改指针** + + +- 单链表 +- 双链表 +- 循环链表 +- 静态链表 + + + +### 单链表 + +线性表的链式存储称作`单链表`，通过**一组任意的存储单元**来存储线性表中的数据元素。 + + +每个链表结点（node）除了存放元素自身的信息外，还需要存放一个指向其后继结点的指针。目的是：**通过指针建立起链表元素之间的线性关系** + + +单链表中结点类型的描述： +```C++ + +// 单链表结点类型定义 +typeof struct LNode{ + ElemType data; // 数据域 + struct LNode *next; // 指针域 +}LNode , *LinkList; + +``` + + +单链表可以解决顺序表需要大量连续存储空间的缺点，但是单链表在数据域的基础上附加了指针域，存在浪费存储空间的缺点； + + +单链表的元素是**离散地分布**在存储空间中的，因此**单链表是非随机存取的存储结构**，不能直接找到表中特定的结点，需要从头开始遍历、一次查找； + + +通常，**头指针用来标识一个单链表**。头指针指向`NULL`时，标识单链表为空。 + + + +#### 头结点 + +为了操作上的方便，在单链表第一个结点之前附加一个结点，叫做**头结点**。 + +- 头结点的数据域可以不存任何信息、也可以记录表长等基础信息 +- 头结点的指针域指向线性表的第一个元素结点； + + + + +**不论单链表是否带头结点（可选），头指针始终指向链表的第一个结点。** + +头结点是带头结点的链表中的第一个结点【重要】 + +- 头结点的数据域可以不存任何信息、也可以记录表长等基础信息 +- 头结点的指针域指向线性表的第一个元素结点； + + +头结点的优点： + +- 因为开始结点的位置被存放在头结点的指针域中，所以在链表的第一个位置上的操作和在表的其他位置上的操作一致，不需要进行特殊处理； +- 无论链表是否为空，头指针始终是指向头结点的头结点的非空指针【空表中，往往就只有头结点，此时头结点的指针域为空，可以有效避免头指针空指针异常问题】-----> **头结点的引入，很好的统一了空表和非空表的操作；** + + + +#### 头插法 + +> 从空表开始，生成新的结点，将读取的数据存放在新结点的数据域中，将新结点插入到当前链表的表头【头结点之后】 + + +```C++ +/* + * @Description: 单链表头插法创建 + * @Version: Beta1.0 + * @Author: 【B站&公众号】Rong姐姐好可爱 + * @Date: 2020-03-04 23:38:04 + * @LastEditors: 【B站&公众号】Rong姐姐好可爱 + * @LastEditTime: 2020-03-04 23:39:16 + */ +LinkList CreateListWithStartNode(LinkList &L){ + + LNode *s; + int x; + L=(LinkList)malloc(sizeof(LNode)); // 创建头结点L + L->next=NULL; // 初始化空链表 + + // 控制台输入值 + scanf("%d",&x); + + // 输入9999 表示结束 + while(x!==9999){ + // 开辟新结点存储空间 + s=(LNode*)malloc(sizeof(LNode)); + // 结点数据域赋值 + s->data=x; + // 修改指针，新结点插入表中【注意：L->next为头结点的指针域】 + s->next=L->next; + L->next=s; + scanf("%d",&x); + } + + // 返回单链表 + return L; +} + + +``` + +特点： + +- 读入数据的顺序与生成的链表中的元素顺序是相反的【结合队列先进先出思考】 +- 每个结点插入的时间复杂度为O(1),单链表长度为n时，头插法的时间复杂度为O(n)【结合算法中的while循环，可以很明确看出时间复杂度】 + + +#### 尾插法 + +头插法建立的单链表，链表中结点的次序和输入数据的顺序不一致【相反】，尾插法则很好的避免了这个问题； + +>新结点插入到当前链表的表尾上，必须增加一个尾指针r,始终指向当前链表的尾结点； + + +```C++ + +/* + * @Description: 单链表尾插法创建 + * @Version: Beta1.0 + * @Author: 【B站&公众号】Rong姐姐好可爱 + * @Date: 2020-03-04 23:38:04 + * @LastEditors: 【B站&公众号】Rong姐姐好可爱 + * @LastEditTime: 2020-03-04 23:39:16 + */ +LinkList CreateListWithEndNode(LinkList &L){ + + + int x; // 输入结点值 + L=(LinkList)malloc(sizeof(LNode)); + LNode *s; // 新结点s + LNode *r=L; // r为尾指针 + + // 控制台输入值 + scanf("%d",&x); + + while(x!==9999){ + // 开辟新结点存储空间 + s=(LNode *)malloc(sizeof(LNode)); + + // 新结点s的数据域赋值为x + s->data=x; + // 单链表L的尾指针指向新的结点s + r->next=s; + + // 指针r指向新的表尾结点 + r=s; + + scanf("%d",&x); + } + + // 表尾指针置空【重要】 + r->next=NULL; + + // 返回单链表 + return L; + +} + +``` + +特点： + +- 读入数据的顺序与生成的链表中的元素顺序完全一致 +- 每个结点插入的时间复杂度为O(1),单链表长度为n时，尾巴插法的时间复杂度为O(n)【结合算法中的while循环，可以很明确看出时间复杂度】 +- 相比头插法附设了一个指向表尾结点的指针，但时间复杂度与头插法相同 + + + +#### 按序号查找 + +> 在单链表中从第一个结点出发，顺指针next域逐个往下搜索、遍历，直到找出第i个结点为止，否则返回最后一个结点指针域NULL + + +```C++ + +/* + * @Description: 单链表按序号查找 + * @Version: Beta1.0 + * @Author: 【B站&公众号】Rong姐姐好可爱 + * @Date: 2020-03-04 23:38:04 + * @LastEditors: 【B站&公众号】Rong姐姐好可爱 + * @LastEditTime: 2020-03-04 23:39:16 + */ +LNode *GetElem(LinkList L,int i){ + int j=1; // 查询计数，初始为1 + LNode *p=L->next; // 单链表头结点指针赋值给指针p + + + // 第0个元素，则指向头结点，返回头结点 + if(i==0){ + // 头结点包含数据域和指针域 + return L; + } + + // 不等于0，却小于1，则i为负数无效，直接返回NULL，查询结果空； + if(i<1){ + return NULL; + } + + // p存在且计数没有走到初始i的位置 + while(p&&jnext; + + // 计数标记+1 + j++; + } + + // 注意： 当p不存在时， 跳出循环，p=NULL; 当p存在但是j大于等于i，跳出循环，返回查找的结果，返回p + // 从跳出循环上来分析，p要么存在即：找到的结点元素，要么为空即NULL + + // 跳出循环，返回第i个结点的指针 + return p; + +} +``` + +需要遍历（扫描）单链表，时间复杂度为：O(n) + + + +#### 按值查找 + +> 从单链表的第一个结点开始，从前往后依次比较表中个结点数据域的值，等于给定值e，则返回该结点的指针；若整个单链表【遍历完】中没有数据域值为e的结点，则返回NULL； + + +```C++ + +/* + * @Description: 单链表按值查找 + * @Version: Beta1.0 + * @Author: 【B站&公众号】Rong姐姐好可爱 + * @Date: 2020-03-04 23:38:04 + * @LastEditors: 【B站&公众号】Rong姐姐好可爱 + * @LastEditTime: 2020-03-04 23:39:16 + */ +LNode *LocateElem(LinkList L,ElemType e){ + + // 指针【哨兵】 + LNode *p=L->next; + // 从第1个结点开始查找数据域(data)为e的结点 + while(p!=NULL&&p->data!=e){ + // 无法匹配，指针后移 + p=p->next; + } + + // 注意：p为NULL的时候，说明单链表已经遍历的尾结点了，跳出循环，没有找到目标结点； + + // 查找到第1个匹配的结点，跳出循环，返回结点指针 + return p; + // +} + +``` +链表遍历无法匹配，会返回NULL,因为在尾结点无法匹配的时候，直接返回尾结点指针域 + +需要遍历（扫描）单链表，时间复杂度为：O(n) + + +#### 结点插入 + +> 单链表中，将值为x的新结点插入到单链表的第i个位置上 + +- 第一步： 检查插入位置的合法性； +- 第二步： 找到待插入位置的前驱结点，即第（i-1）个结点； +- 第三部： 在前驱结点后插入新结点； + +```C++ + // 循环遍历，时间复杂度O(n) + p=GetElem(L,i-1); + + // 移动指针，时间复杂度O(1) + s->next=p->next; + p->next=s; +``` + +结合上面的代码可以看出，将元素x插入到单链表L的第i个元素上，必须先找到单链表L的i个结点的前驱结点，即（i-1）的位置，需要采用`GetElem()`函数，按照序号查找； + +如果返回的前驱结点不为空，则说明插入的位置i合法，否则位置非法，插入失败； + +找到前驱结点p后，最重要的是移动指针，将新的结点s的指针域指向结点p的指针域，也就是s的指针域指向元素p的后继结点，第i个结点元素 + +原来的(i-1)位置上的元素，也就是前驱结点p的指针域则必须指向新的结点元素； + +**上面的过程不能更换，避免后继指针不存在的问题** + + +最后的最后，一定要注意将s的数据域赋值x + + +插入结点的时间复杂度集中在查找第(i-1)个元素，时间复杂度为O(n);如果在给定结点的后面插入新结点，只需要执行`p->next=s`操作，时间复杂度为O(1) + + + +##### 前插操作 + +> 在某结点的前面插入一个新的结点 + +**对结点的前插操作都可以转化为后插操作，前提：需要从单链表的头结点开始顺序查找到其前驱结点；时间复杂度为O(n)。** + +##### 后插操作 + +> 在某结点的后面插入一个新的结点，单链表插入算法中，通常采用后插操作的 + + +```C++ + +// 结点s插入到结点p的前面，修改指针域，顺序不能改变 +s->next=p->next; +p->next=s; + + +// 经典的借助变量，进行值交换 +temp=p->data; +p->data=s->data; +s->data=temp; + +``` + +上述借助临时变量`temp`来将结点s和结点p的数据域进行交换，需要开辟O(1)的空间复杂度，但是时间复杂度却从O(n)改变为O(1)，典型的空间换时间策略 + + +#### 删除结点 + +> 将单链表L的第i个结点元素删除； + + +- 第一步： 先检查删除位置的合法性； +- 第二步： 查找表中的第（i-1）个结点，即被删结点的前驱结点； +- 第三步： 移动指针，删除结点元素； + + +```C++ + +// 获取删除位置结点元素的前驱结点 +p=GetElem(L,i-1); + +// 删除位置结点元素指针 +q=p->next; + +// 修改指针，将删除位置结点元素前驱结点的指针域指向其后继结点 +p->next=q->next; + +// 释放结点元素的内存控件 +free(q) + +``` + +和插入算法一样，时间都消耗在查询前驱结点上，时间复杂度为：O(n) + + + + +> 删除单链表L中给点结点元素*p，通常是按值查找获取到p结点的前驱元素，再执行删除操作，这样很明显会导致时间复杂度为：O(n)，主要都消耗在`按值查找`上 + +这里可以利用p结点的后继结点将p结点删除 + +- 第一步：申请结点q，使其只想p结点的后继结点； +- 第二步：将p结点的数据域值换成其后继结点的数据域；【注意，交换没什么意义，最终p的后继结点会删除、释放】 +- 第三步：p的指针域指向q的指针域，q结点从链中“断开” +- 第四步：释放q的内存空间 + + +```C++ + // 存放p的后继结点指针 + q=p->next; + + // 结点p的后继结点元素赋值给结点p，避免后继结点的数据域丢失 + p->data=p->next->data; + p->next=q->next; + + // 此时q指向更换数据域后的p，即原来p的后继结点 + free(q) + +``` + +相比按值查找前驱结点来删除给定的结点p，利用后继结点来删除的时间复杂度更小，为：O(1) + + + +#### 计算表长 + +> 计算单链表中数据结点（不含头结点）的个数 + + +算法思路：从第一个结点开始顺序依次访问表中的每一个结点，为此需要设置一个`计数器变量`，每访问一个结点，计算器加1，直到访问到空结点为止。 + +算法时间复杂度：O(n) + + +**单链表的长度是不包括头结点的，不带头结点和带头结点的单链表在求表长操作上会略有不同。** + +不带头结点的单链表，当表为空时候，需要单独处理； + +```C++ +// 不带头结点的单链表L为空,判定条件是L=NULL。 +if(L===NULL){ +// 链表为空，表长为0 + return 0; +} + +// 带头结点的单链表L为空，判空条件：L->next=NULL; + +if(L->next===NULL){ + // 链表为空，不包含头结点，表长为0 + return 0; +} + +``` \ No newline at end of file diff --git a/数据结构/线性表/4.线性表的链式表示【双链表】.md b/数据结构/线性表/4.线性表的链式表示【双链表】.md new file mode 100644 index 0000000..d56e0f9 --- /dev/null +++ b/数据结构/线性表/4.线性表的链式表示【双链表】.md @@ -0,0 +1,92 @@ + + + + + +## 双链表 + + +从单链表的结构上来看 +- 访问特定结点的前驱结点需要遍历整个单链表，移动指针，时间复杂度为：O(n) +- 访问特定结点的后继结点只需要移动一次指针，时间复杂度为：O(1) + + +双链表的引入，很好的解决单链表访问前驱结点时间消耗大的问题。 + + +双链表结点由三部分组成： + +- `数据域` 存放数据信息 +- `prior指针域` 指向结点的前驱结点 +- `next指针域` 指向结点的后继结点 + + +```C++ + +// 双链表结点类型 +typedef struct DNode{ + ElemType data; // 结点的数据域 + struct DNode *prior; // 结点的前驱指针 + struct DNode *next; // 结点的后继指针 +}DNode, *DlinkList; + +``` + + +### 基本特点 + +- 双链表仅仅在单链表的结点中增加了一个指向结点前驱的`prior`指针； +- `按值查找`、`按序号查找`在单链表和双链表上的操作是相同的。 +- 和单链表不同，`插入`、`删除`操作除了修改`next`指针域，双链表还需要修改`prior`指针域，确保不断`链`，时间复杂度都为：O(1) + + + + +### 插入结点 + +> 在双链表中p所指的结点之后插入结点s + + +```C++ + +// 第一步 +s->next=p->next; + +// 第二步 +p->next->prior=s; + +// 第三步 +s->prior=p; + +// 第四步 +p->next=s + +``` + +**第一步和第二步必须再第四步之前**，整体时间复杂度为：O(1) + +### 删除结点 + +> 删除双链表中结点p的后继结点q + +```C++ + +// 第一步 +p->next=q->next; + +// 第二步 +q->next->prior=p; + +// 第三步 +free(q); + +``` + +**第一步和第二步顺序可换**，整体时间复杂度为：O(1) \ No newline at end of file diff --git a/数据结构/线性表/5.线性表的链式表示【循环链表】.md b/数据结构/线性表/5.线性表的链式表示【循环链表】.md new file mode 100644 index 0000000..8de1fa7 --- /dev/null +++ b/数据结构/线性表/5.线性表的链式表示【循环链表】.md @@ -0,0 +1,76 @@ + + + + + +## 循环链表 + +- 循环单链表 +- 循环双链表 + + +### 循环单链表 + +`循环单链表`是在单链表的基础上，将最后一个结点（尾结点）的指针由`NULL`改为指向`头结点`，形成`环`。【单链表----->循环单链表】 + + +```C++ +// 双链表结点类型 +typedef struct DNode{ + ElemType data; // 结点的数据域 + struct DNode *prior; // 结点的前驱指针 + struct DNode *next; // 结点的后继指针 +}DNode, *DlinkList; + +``` + +#### 判空条件 + +**不是判断头结点的指针是否为空，而是需要判断是否等于头指针**，表为空时，头结点的next指针域其实是指向自己； + + + +#### 特点 + +- 在循环单链表中，尾结点*p的next指针域指向链表L（即：头结点），形成了`闭环`,不存在指针域为`NULL`的结点。 +- **由于循环单链表是个`环`,在任何位置上的插入、删除操作都是等价的，不需要去判断是否是表尾**。当其中的结点的next指针指向自己，也就能判断表为空 +- 单链表只能从头结点（表头结点）开始往后顺序遍历整个表，循环单链表可以从表中任意位置开始遍历整个链表，结点是等价的； +- **循环单链表可以抽象为时钟，形成的`环`是有顺序的；** +- 频繁的`表头`和`表尾`操作，可以对循环单链表设置`尾指针`，而不设置`头指针`，明确尾指针r后，头指针即为：`r->next` ，减少头指针到尾指针间的遍历，时间复杂度:O(n)---->O(1) + + + + +### 循环双链表 + +`循环双链表`是在双链表的基础上，将`尾结点`的`next`指针指向`头结点`，将`头结点`的`prior`指针指向`尾结点`。【双链表----->循环双链表】 + + +```C++ +// 双链表结点类型 +typedef struct DNode{ + ElemType data; // 结点的数据域 + struct DNode *prior; // 结点的前驱指针 + struct DNode *next; // 结点的后继指针 +}DNode, *DlinkList; + +``` + +#### 判空条件 + +循环双链表为空时，头结点*p的prior指针和next指针都指向L，即同时满足： + +- p->next=L +- p->prior=L + + +#### 基本特点 + +- 从双向链表中的任意一个结点开始，都可以很方便地访问它的`前驱结点`和`后继结点`。 \ No newline at end of file diff --git a/数据结构/线性表/6.线性表的链式表示【静态链表】.md b/数据结构/线性表/6.线性表的链式表示【静态链表】.md new file mode 100644 index 0000000..0ef36bf --- /dev/null +++ b/数据结构/线性表/6.线性表的链式表示【静态链表】.md @@ -0,0 +1,44 @@ + + + + + +## 静态链表 + +> 借助数组来描述线性表的链式存储结构，结点元素同样存在数据域`data`和指针域`next` + + +注意： 和普通的链表的指针域不同的是，静态链表的指针是结点元素的相对地址(数组下标)，也称为`游标`，建议结合高级语言中数组的概念来理解； + + +**与顺序表一样，虽然静态链表属于链表，但是存储时需要预先分配一块连续的内存空间** + + +静态链表结构类型： + + +```C++ + +// 定义静态链表的最大长度 +# define MaxSize 50 + +typedef struct{ + ElemType data; // 存储数据元素，数据域 + int next; // 下个元素的相对地址，数组下标 +}SLinkList[MaxSize]; + +``` + +很显然，静态链表是通过`数组游标`来访问下一个结点元素，可以和`指针域`的相关概念结合理解； + + +- 静态链表以`next=-1`作为结束的标志【尾结点】 +- 和动态链表相同，**插入、删除操作不需要移动元素，只需要修改指针**； +- 总体来说，静态链表没有单链表使用方便，需要将整个链表存储在一块连续的内存空间中，内部的存储可以分散，通过指针构成`链`的关系 \ No newline at end of file diff --git a/数据结构/线性表/7.顺序表和链表的比较.md b/数据结构/线性表/7.顺序表和链表的比较.md new file mode 100644 index 0000000..67e5f9d --- /dev/null +++ b/数据结构/线性表/7.顺序表和链表的比较.md @@ -0,0 +1,72 @@ + + + + +## 顺序表和链表的比较 + + +### 存取方式 + +- 顺序表支持顺序存取和随机存取； +- 链表只能从表头顺序存取元素，支持顺序存取； + + +### 逻辑结构与物理结构 + + +- 顺序存储时，逻辑上相邻的元素，对应的物理存储位置也相邻【一定性】。 +- 链式存储时，逻辑上相邻的元素，对应的物理存储位置不一定相邻【可以相邻，也可以不相邻】。 +- 链式存储的逻辑关系通过指针链接表示； + + + +### 时间复杂度 + +#### 按值查找 + +- 顺序表无序的情况下，顺序表和链表的时间复杂度均为O(n) +- 顺序表有序的情况下，顺序表的时间复杂度为O(log2n)，链表的时间复杂度为O(n)； + + +**注意：O(log2n) < O(n)** + +#### 按序号查找 + +- 顺序表支持随机访问，时间复杂度为O(1)； +- 顺序表不支持随机访问，时间复杂度为O(n)； + +#### 插入、删除 + +- 顺序表平均需要移动半个表长的元素； +- 链表只需要修改相应结点的指针域，不需要移动元素； +- 链表结点除了数据域，还有指针域，在存储空间上比顺序存储需要更大的存储空间，付出更大的存储代价，存储密度不够大 + +### 空间分配 + +#### 顺序存储 + + +##### 静态分配 + +- 需要预先分配足够大的存储空间； +- 空间装满后不能扩充，存储新元素将出现`内存溢出`； +- 存储空间过大，顺序表后部闲置空间过多，造成`内部碎片` +- 存储空间过小，会造成`内存溢出` + +##### 动态分配 + +- 动态分配能够扩充存储空间，但需要移动大量元素，操作效率降低 +- 内存中没有更大块的连续存储空间，将会导致空间分配失败； + + +#### 链式存储 + +- 链式存储的结点空间只在需要的时候申请分配 +- 只要内存由空间就可以分配，操作灵活、高效 \ No newline at end of file diff --git a/数据结构/线性表/8.存储结构的选取.md b/数据结构/线性表/8.存储结构的选取.md new file mode 100644 index 0000000..c2b89c5 --- /dev/null +++ b/数据结构/线性表/8.存储结构的选取.md @@ -0,0 +1,45 @@ + + + + + +## 存储结构的选取 + + + +### 基于存储的考虑 + +- 对线性表的长度和存储规模难以估计时，不宜采用顺序表存储 +- 链表不用事先估计存储规模，但存储密度较低 +- 链式存储结构的存储密度小于1，不要求连续的存储空间 + + + +### 基于运算的考虑 + +- 顺序表支持随机存取，按序号查找顺序表的时间复杂度为O(1)； +- 链表不支持随机存取，按序号查找链表的时间复杂度为O(n); +- 顺序表的插入、删除操作，平均需要移动表中一半的元素，当表的数据量较大时，这种情况需要重点考虑的。 +- 链表的插入、删除操作，也是需要找插入位置（前驱结点、后继结点），主要的操作还是比较操作，相对较好； + + + + +### 基于环境的考虑 + +- 顺序表容易实现，任何高级语言中都有数组类型； +- 链表操作是基于指针的，指针移动，相对复杂； + + + +综上比较 + +- 通常比较稳定的线性表选择顺序存储； +- 频繁进行插入、删除操作的线性表，应该选择链式存储，动态性较强 \ No newline at end of file diff --git a/数据结构/线性表/9.零碎知识补充.md b/数据结构/线性表/9.零碎知识补充.md new file mode 100644 index 0000000..0b6d07e --- /dev/null +++ b/数据结构/线性表/9.零碎知识补充.md @@ -0,0 +1,33 @@ + + + + +## 零碎知识补充 + +- 无论是链表的插入还是删除操作，必须保证不断链【重要】 +- 顺序存储结构可以随机存取也能顺序存取，链式结构只能进行顺序存取 +- 顺序存储方式同样适合图和树的存储，例如：满二叉树的顺序存储 +- 队列需要在表头删除元素，在表尾插入元素【先进先出】，采用带尾指针的循环单链表比较方便 +- 数组排序最少时间复杂度为O(nlog2n)【重要】 +- 静态链表中的指针称为`游标`，指示下一个元素在数组中的`下标` +- 静态链表用数组表示，需要预先分配较大的连续空间，同时具有一般链表的特点（插入、删除元素不需要移动元素） + + +### 单链表设置头结点 + + +目的 + +> 主要是方便运算。 + +好处 + +- 有头结点后，插入、删除数据元素的算法统一起来了，不需要判断是否在第一个元素之前插入或者删除第一个元素了。 +- 不论链表是否为空，头指针是指向头结点的`非空指针`，链表的头指针不变，因此空链表和非空链表的处理也就统一起来了。 diff --git a/数据结构/线性表/线性表.png b/数据结构/线性表/线性表.png new file mode 100644 index 0000000..f6fdcdf Binary files /dev/null and b/数据结构/线性表/线性表.png differ diff --git a/数据结构/线性表/线性表的存储结构.png b/数据结构/线性表/线性表的存储结构.png deleted file mode 100644 index a1dd540..0000000 Binary files a/数据结构/线性表/线性表的存储结构.png and /dev/null differ diff --git a/数据结构/线性表/顺序表插入平均时间复杂度计算.png b/数据结构/线性表/顺序表插入平均时间复杂度计算.png deleted file mode 100644 index 0eede62..0000000 Binary files a/数据结构/线性表/顺序表插入平均时间复杂度计算.png and /dev/null differ diff --git a/数据结构/线性表/顺序表随机删除元素的平均复杂度计算.png b/数据结构/线性表/顺序表随机删除元素的平均复杂度计算.png deleted file mode 100644 index 020bbda..0000000 Binary files a/数据结构/线性表/顺序表随机删除元素的平均复杂度计算.png and /dev/null differ