数据结构完结

对原有的文件添加上序号

Data-Structrue/0-introduction.md

@@ -1,115 +1,115 @@
-# 绪论
-
-## 基本概念
-
-+ 数据项：一个数据元素由若干个数据项组成。
-+ 数据元素：组成数据对象的基本单元。
-+ 数据对象：性质相同的数据元素的集合。
-
-### 数据类型与抽象数据类型
-
-数据类型是一个值的集合和定义在此集合上的一组操作的总称。
-
-+ 原子类型：其值不可再分的数据类型。
-+ 结构类型：其值可以再分解为若干成分（分量）的数据类型。
-
-抽象数据类型ADT用数学化的语言定义数据的逻辑结构、定义运算。与具体的实现无关。
-
-## 数据结构三要素
-
-+ 逻辑结构：元素之间的逻辑关系：线性结构、非线性结构 || 集合、线性结构、树结构、网状结构。
-+ 存储结构：数据在计算机中的表示（映像），也称物理结构：顺序存储结构（顺序表）、链式存储结构（链表）、索引存储（索引表）、散列存储（散列表、哈希表）。
-+ 数据运算：运算的定义是针对逻辑结构的，指出运算的功能；运算的实现是针对存储结构的，指出运算的具体操作步骤。
-
-## 算法
-
-程序=数据结构+算法。算法为了处理信息。
-
-### 算法的特性
-
-+ 有穷性。
-+ 确定性。
-+ 可行性。
-+ 输入。
-+ 输出。
-
-### 好算法的特点
-
-+ 正确性。
-+ 可读性。
-+ 健壮性。
-+ 高效率与低储量需求。
-
-### 效率度量
-
-#### 时间复杂度
-
-时间开销$T(n)$与问题规模$n$的关系。
-
-当n规模够大时可以只考虑阶数高的部分。即$T(n)=O(T(n))$。
-
-+ $T(n)=f(n)+g(n)=O(f(n))+O(g(n))=O(\max(f(n),g(n)))$。多项相加只保留最高阶的项，系数为1。
-+ $T(n)=f(n)×g(n)=O(f(n))×O(g(n))=O(\max(f(n)×g(n)))$。多项相乘就都保留。
-+ $O(1)<O(\log_2n)<O(n)<O(n\log_2n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)$。
-
-如$T(n)=n^3+n^2\log_2n=O(n^3)+O(n^2\log_2n)=O(n^3)$。
-
-+ 顺序执行的代码只会影响常数项，可以忽略。
-+ 循环就代表一个n，并列的循环不会叠加复杂度，只有嵌套的循环才会，嵌套的循环深度就是复杂度的幂数，具体的情况需要看循环内代码的逻辑分析。
-
-```c
-void loop(int n){
-    int i = 1;
-    while(i<=n){
-        i=i*1;
-    }
-}
-```
-
-这个代码的时间复杂度就是$O(\log_2n)$。
-
-```c
-// 假定数组中乱序存储1到n的整数
-int array[n]={...};
-void check(int array[], int n){
-    for(int i=0; i<n; i++){
-        if(array[i]==n){
-            printf("%d", i);
-            break;
-        }
-    }
-}
-check(array, n);
-```
-
-这个代码的执行时间依托于输入数据：
-
-+ 最好情况：元素$n$在第一个位置，$T(n)=O(1)$。
-+ 最坏情况：元素$n$在最后一个位置，$T(n)=O(n)$。
-+ 平均情况：$n$在任意一个位置概率相同，$T(n)=T((1+n)/2)=O(n)$。
-
-在实际考虑时只会考虑最坏情况和平均情况。
-
-#### 空间复杂度
-
-存储空间S(n)与问题规模n的关系。
-
-算法原地工作是指算法所需的内存空间为常数级。
-
-当n规模够大时可以只考虑阶数高的部分。即$S(n)=O(S(n))$。
-
-空间复杂度主要看程序所需要的变量所要的空间，一阶数组就是$n$，二阶就是$n$的二次方。
-
-同时函数递归调用也会带来内存开销。当每一次递归调用的空间相等时，空间复杂度=递归调用的深度。
-
-```c
-void check(int n){
-    int array[n];
-    if(n > 1) {
-        check(n-1)
-    }
-}
-check(n);
-```
-
-此时每一次的递归会使变量空间减去1，所以$S(n)=S((1+n)n/2)=O(n^2)$。
+# 绪论
+
+## 基本概念
+
++ 数据项：一个数据元素由若干个数据项组成。
++ 数据元素：组成数据对象的基本单元。
++ 数据对象：性质相同的数据元素的集合。
+
+### 数据类型与抽象数据类型
+
+数据类型是一个值的集合和定义在此集合上的一组操作的总称。
+
++ 原子类型：其值不可再分的数据类型。
++ 结构类型：其值可以再分解为若干成分（分量）的数据类型。
+
+抽象数据类型ADT用数学化的语言定义数据的逻辑结构、定义运算。与具体的实现无关。
+
+## 数据结构三要素
+
++ 逻辑结构：元素之间的逻辑关系：线性结构、非线性结构 || 集合、线性结构、树结构、网状结构。
++ 存储结构：数据在计算机中的表示（映像），也称物理结构：顺序存储结构（顺序表）、链式存储结构（链表）、索引存储（索引表）、散列存储（散列表、哈希表）。
++ 数据运算：运算的定义是针对逻辑结构的，指出运算的功能；运算的实现是针对存储结构的，指出运算的具体操作步骤。
+
+## 算法
+
+程序=数据结构+算法。算法为了处理信息。
+
+### 算法的特性
+
++ 有穷性。
++ 确定性。
++ 可行性。
++ 输入。
++ 输出。
+
+### 好算法的特点
+
++ 正确性。
++ 可读性。
++ 健壮性。
++ 高效率与低储量需求。
+
+### 效率度量
+
+#### 时间复杂度
+
+时间开销$T(n)$与问题规模$n$的关系。
+
+当n规模够大时可以只考虑阶数高的部分。即$T(n)=O(T(n))$。
+
++ $T(n)=f(n)+g(n)=O(f(n))+O(g(n))=O(\max(f(n),g(n)))$。多项相加只保留最高阶的项，系数为1。
++ $T(n)=f(n)×g(n)=O(f(n))×O(g(n))=O(\max(f(n)×g(n)))$。多项相乘就都保留。
++ $O(1)<O(\log_2n)<O(n)<O(n\log_2n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)$。
+
+如$T(n)=n^3+n^2\log_2n=O(n^3)+O(n^2\log_2n)=O(n^3)$。
+
++ 顺序执行的代码只会影响常数项，可以忽略。
++ 循环就代表一个n，并列的循环不会叠加复杂度，只有嵌套的循环才会，嵌套的循环深度就是复杂度的幂数，具体的情况需要看循环内代码的逻辑分析。
+
+```c
+void loop(int n){
+    int i = 1;
+    while(i<=n){
+        i=i*1;
+    }
+}
+```
+
+这个代码的时间复杂度就是$O(\log_2n)$。
+
+```c
+// 假定数组中乱序存储1到n的整数
+int array[n]={...};
+void check(int array[], int n){
+    for(int i=0; i<n; i++){
+        if(array[i]==n){
+            printf("%d", i);
+            break;
+        }
+    }
+}
+check(array, n);
+```
+
+这个代码的执行时间依托于输入数据：
+
++ 最好情况：元素$n$在第一个位置，$T(n)=O(1)$。
++ 最坏情况：元素$n$在最后一个位置，$T(n)=O(n)$。
++ 平均情况：$n$在任意一个位置概率相同，$T(n)=T((1+n)/2)=O(n)$。
+
+在实际考虑时只会考虑最坏情况和平均情况。
+
+#### 空间复杂度
+
+存储空间S(n)与问题规模n的关系。
+
+算法原地工作是指算法所需的内存空间为常数级。
+
+当n规模够大时可以只考虑阶数高的部分。即$S(n)=O(S(n))$。
+
+空间复杂度主要看程序所需要的变量所要的空间，一阶数组就是$n$，二阶就是$n$的二次方。
+
+同时函数递归调用也会带来内存开销。当每一次递归调用的空间相等时，空间复杂度=递归调用的深度。
+
+```c
+void check(int n){
+    int array[n];
+    if(n > 1) {
+        check(n-1)
+    }
+}
+check(n);
+```
+
+此时每一次的递归会使变量空间减去1，所以$S(n)=S((1+n)n/2)=O(n^2)$。

Data-Structrue/10-sort.md

@@ -329,8 +329,76 @@ $n$个元素二路归并排序，归并一共要$\log_2n$趟，每次归并时
 
 ### 外部排序的原理
 
+#### 外部排序的过程
+
 磁盘的读写是以块为单位，数据读入内存后才能被修改，修改完成后还需要写回磁盘。
 
 外部排序就是针对数据元素太多，无法一次性全部读入内存进行排序而进行处理的在外部磁盘进行的排序处理方式。
 
 使用归并排序的方式，最少只用在内存分配三块大小的缓冲区即可堆任意一个大文件进行排序。然后对缓冲区里的数据进行内部排序。
+
+外部排序的过程：
+
+1. 生成初始归并段，需要读写并进行内部排序
+2. 重复读写，进行内部归并。
+
+外部排序时间开销=读写外存时间（最大的时间开销）+内部排序所需时间+内部归并所需时间。
+
+#### 外部排序的优化方法
+
+优化方法就是使用更多路的多路归并，减少归并趟数。
+
+$k$路平衡归并：最多只能有$k$个段归并为一个；每一趟归并中，若有$m$个归并段参与归并，则经过这一趟处理得到$\lceil\dfrac{m}{k}\rceil$个新的归并段。
+
+对$r$个初始归并段，使用$k$路归并，则归并树可以使用$k$叉树表示，若树高为$h$，则归并趟数为$h-1=\lceil\log_kr\rceil$。
+
+但是多路归并会带来负面影响：
+
+1. $k$路归并时，需要开辟$k$个输入缓冲区，内存开销增加。
+2. 每挑选一个关键字需要对比关键字$(k-1)$次，内部归并时间增加。
+
+同时，若能增加初始归并段的长度，也可以减少初始归并段数量$r$从而进行优化。
+
+### 败者树
+
+用于通过过去归并的经历减少归并次数。败者树可以看作一棵多了一个单个的根的完全二叉树。$k$个叶结点分别是当前参加比较的元素，非叶子结点用来记忆左右子树中的失败者，而让胜者往上继续比较，一直到根结点。
+
+传统方法从$k$个归并段选出一个最大或最小元素需要对比关键字$k-1$次，而使用$k$路归并的败者树只需要对比关键字$\lceil\log_2k\rceil$次。
+
+### 置换选择排序
+
+用于构建更长的初始归并段，从而减少归并次数。
+
+假设初始始待排文件为FI，初始归并段输出文件为FO，内存工作区为WA，FO和WA的初始状态为空，WA可容纳$w$个记录。置换选择算法的步骤如下：
+
+1. 从FI输入$w$个记录到工作区WA。.
+2. 从WA中选出其中关键字取最小值的记录，记为MINIMAX记录。
+3. 将MINIMAX记录输出到FO中去。
+4. 若FI不空，则从FI输入下一个记录到WA中。
+5. 从WA中所有关键字比MINIMAX记录的关键字大的记录中选出最小关键字记录，作为新的MINIMAX记录。
+6. 重复步骤三到五，直至在WA中选不出新的MINIMAX记录为止，由此得到一个初始归并段，输出一个归并段的结束标志到FO中去。准备输出新的归并段。
+7. 重复步骤二到六，直至WA为空。由此得到全部初始归并段。
+
+此时输出的初始归并段可以超过WA，且初始归并段长度是不一定相等的。
+
+### 最佳归并树
+
+#### 最佳归并树的衡量
+
+每个初始归并段可以看作一个叶子结点，归并树的长度作为结点权值，则归并树的带权路径长度WPL等于读写磁盘的次数。从而归并过程中的磁盘IO次数=归并树的WPL*2。
+
+#### 最佳归并树的构造
+
+所以就需要一棵类似哈夫曼树来成为最佳的归并树，不断选择最小的$k$段进行归并。
+
+#### 添加虚段
+
+对于$k$叉归并来说，若初始归并段的数量无法构成严格的$k$叉归并树，则需要补充几个长度为0的虚拟段，再进行$k$叉哈夫曼树的构造。
+
+那么添加多少虚段呢？
+
+$k$叉的最佳归并树一定是一棵严格的$k$叉树，即树种只包含度为$k$和0的结点。
+
+设度为$k$的结点有$n_k$个，度为0的结点有$n_0$个，归并树的总结点树为$n$，则初始归并段数量+虚段数量=$n_0$。
+
+所以$n=n_0+n_k$，$kn_k=n-1$，所以$n_0=(k-1)n_k+1$，所以$n_k=\dfrac{(n_0-1)}{(k-1)}$一定是可以整除的。如果不整除就要添加虚段。

Data-Structrue/5-array.md

@@ -0,0 +1,83 @@
+# 数组
+
+## 数组的定义
+
+数组是由同类型的数据元素构成的有序集合，每个元素是数组元素，每个元素受$n$个线性关系的约束。其中每个元素在$n$个线性关系中的序号就是元素的下标，可以通过下标来访问元素。
+
+数组是对线性表的推广。
+
+数组一旦被定义其维数和维界就不能改变，所以数组只能对结构的初始化和销毁，以及元素的存取和修改。
+
+## 数组的存储结构
+
+### 一维数组
+
+各数组元素大小相同，且物理上连续存放。
+
+数组元素a[i]的存放地址=起始地址LOC+i*sizeof(ElemType)。数组下标从0开始。
+
+### 二维数组
+
+二维数组存储方式还是同一维数组一样连续的。
+
++ 行优先：一行一行存储。
++ 列优先：一列一列存储。
+
+已知二维数组b[M][N]。
+
+若按行存储，b[i][j]的存储地址=起始地址LOC+(i\*N+j)*sizeof(ElemType)。
+
+### 十字链表法
+
+每个结点中包含行数、列数、元素值，以及两个指针，向下域指针down指向同第j列的下一个个元素，向右域指针right指向同第i行的下一个元素。
+
+## 特殊数组的压缩
+
+压缩存储指为多个值相同的元素只分配一个存储空间从而节省存储空间。
+
+特殊矩阵是指具有许多相同矩阵元素或零元素，并且这些相同矩阵元素或零元素的分布有一定规律的矩阵。
+
+### 对称矩阵
+
+若对一个$n$阶方阵$A[0,n-1][0,n-1]$中的任意一个元素$a_{ij}$都有$a_{ij}=a_{ji}$，即主对角线对称元素相等的矩阵，就是对称矩阵。
+
+其中元素可以分为上三角区域、主对角线和下三角区域，上下三角区域元素相等。所以可以将$A$存放在一维数组$B[n(n+1)/2]$中，从而$a_{ij}=b_k$，只存放下三角部分与主对角线部分元素。从而$a_{ij}$对应的$k=1+2+\cdots+(i-1)+j-1=\dfrac{i(i-1)}{2}+j-1$。
+
++ 当$i\geqslant j$时，即下三角区域与主对角线元素：$k=\dfrac{i(i-1)}{2}+j-1$。
++ 当$i<j$时，即上三角区域：$k=\dfrac{j(j-1)}{2}+i-1$。
+
+### 三角矩阵
+
+#### 下三角矩阵
+
+下三角矩阵指上三角区域的元素均为同一常量，其存储思想与对称矩阵一样，但是需要最后多一个存储空间存储上三角的常量。所以可以将$A$存放在一维数组$B[n(n+1)/2+1]$中。
+
++ 当$i\geqslant j$时，即下三角区域与主对角线元素：$k=\dfrac{i(i-1)}{2}+j-1$。
++ 当$i<j$时，即上三角区域：$k=\dfrac{n(n-1)}{2}$。
+
+#### 上三角矩阵
+
+上三角矩阵指下三角区域的元素均为同一常量，其存储思想与下三级矩阵一样，不过下标不同。
+
+位于元素$a_{ij}\,(i\leqslant j)$前的元素个数有：第一行有$n$个元素，第二行有$n-1$个元素，第$i-1$行有$n-i+2$个元素，第$i$行有$j-i$个元素。
+
+从而$a_{ij}$对应的$k=n+(n-1)+\cdots+(n-i+2)+(j-i+1)-1=\dfrac{(i-1)(2n-i+2)}{2}+(j-i)$。
+
++ 当$i\leqslant j$时，即上三角区域与主对角线元素：$k=\dfrac{(i-1)(2n-i+2)}{2}+(j-i)$。
++ 当$i>j$时，即下三角区域：$k=\dfrac{n(n-1)}{2}$。
+
+#### 三对角矩阵
+
+对角矩阵也称为带状矩阵。对于$n$阶方阵$A$的任意元素$a_{ij}$，当$\vert i-j\vert>1$时，有$a_{ij}=0$，则是三对角矩阵。
+
+三对角矩阵除了以主对角线为中心的十三条对角线的区域上的元素并不是完全为零外，其他元素都是零。
+
+所以可以将三条对角线上的元素行优先地存储在一维数组中，$k=2i+j-3$，同样$i=\lfloor\dfrac{k+1}{3}+1\rfloor$，$j=k-2i+3$。
+
+#### 稀疏矩阵
+
+若矩阵中非零元素很少，这个矩阵就是稀疏矩阵，若使用普通一维数组存储则十分浪费空间，所以一般只存储非零元素。
+
+所以可以构成三元组(行标,列标,值)来存储。可以使用数组来存储也可以使用之前的十字链表法来存储。
+
+稀疏矩阵压缩后就失去了随机存取的特性。

Data-Structrue/6-general-list.md

@@ -0,0 +1,21 @@
+# 广义表
+
+## 广义表的定义
+
+广义表是线性表的推广，也称为列标。一般记为$LS=(a_1,a_2,\cdots,a_n)$，$n$是广义表的长度，其中$a_n$可以是单个元素也可以是一个广义表，分别称为广义表$LS$的原子和子表。
+
+广义表是一个递归的定义，所以广义表是一个多层次的结构，可以用图来表示。
+
+## 广义表的操作
+
+广义表的结构复杂，所以主要操作时取表头和取表尾。
+
+表头是非空广义表的第一个元素，可以是单原子也可以是一个子表。
+
+表尾是除去表头后由余下元素构成的表，所以一定是一个广义表。
+
+## 广义表的存储结构
+
+因为广义表结构复杂，所以很难用顺序存储的形式实现，一般都是使用链表实现。
+
+一般使用头尾链表与拓展线性链表两种存储结构来实现。

Data-Structrue/array.md

@@ -1,24 +0,0 @@
-# 数组
-
-## 数组的存储结构
-
-### 一维数组
-
-各数组元素大小相同，且物理上连续存放。
-
-数组元素a[i]的存放地址=起始地址LOC+i*sizeof(ElemType)。数组下标从0开始。
-
-### 二维数组
-
-二维数组存储方式还是同一维数组一样连续的。
-
-+ 行优先：一行一行存储。
-+ 列优先：一列一列存储。
-
-已知二维数组b[M][N]。
-
-若按行存储，b[i][j]的存储地址=起始地址LOC+(i\*N+j)*sizeof(ElemType)。
-
-### 十字链表法
-
-每个结点中包含行数、列数、元素值，以及两个指针，向下域指针down指向同第j列的下一个个元素，向右域指针right指向同第i行的下一个元素。