C 语言版
一 数据结构简介
1.1 数据结构学什么
数据结构是关于数据存储方式的一门学科。
数据结构大致包含以下几种存储结构：
- 线性表：顺序表、链表、栈和队列
- 树结构：普通树、二叉树、线索二叉树等
- 图存储结构
1.1.1 线性表
线性表结构存储的数据往往是可以依次排列的，就像小朋友手拉手，每位学生的前面和后面都仅有一个小朋友和他拉手，具备这种“一对一”关系的数据就可以使用线性表来存储。
线性表并不是一种具体的存储结构，它包含顺序存储结构和链式存储结构，是顺序表和链表的统称。
1.1.1.1 顺序表
顺序表，简单地理解，就是常用的数组，只是换了个名字而已，例如使用顺序表存储 {1,3,5,7,9}
由于顺序表结构的底层实现借助的就是数组，因此对于初学者来说，可以把顺序表完全等价为数组，但实则不是这样。数据结构是研究数据存储方式的一门学科，它囊括的都是各种存储结构，而数组只是各种编程语言中的基本数据类型，并不属于数据结构的范畴。
1.1.1.2 链表
我们知道，使用顺序表（底层实现靠数组）时，需要提前申请一定大小的存储空间，这块存储空间的物理地址是连续的。链表则完全不同，使用链表存储数据时，是随用随申请，因此数据的存储位置是相互分离的，换句话说，数据的存储位置是随机的。
为了给各个数据块建立 依次排列 的关系，链表给各数据块增设一个指针，每个数据块的指针都指向下一个数据块（最后一个数据块的指针指向 NULL），就如同一个个小学生都伸手去拉住下一个小学生的手，这样，看似毫无关系的数据块就建立了 依次排列 的关系，也就形成了链表。
1.1.1.3 栈和队列
栈和队列隶属于线性表，是特殊的线性表，因为它们对线性表中元素的进出做了明确的要求。
- 栈
栈中的元素只能从线性表的一端进出（另一端封死），且要遵循先入后出的原则，即先进栈的元素后出栈。
栈结构如图所示，像一个木桶，栈中含有 3 个元素，分别是 A、B 和 C，从在栈中的状态可以看出 A 最先进的栈，然后 B 进栈，最后 C 进栈。根据“先进后出”的原则，3 个元素出栈的顺序应该是：C 最先出栈，然后 B 出栈，最后才是 A 出栈。
- 队列
队列中的元素只能从线性表的一端进，从另一端出，且要遵循先入先出的特点，即先进队列的元素也要先出队列(FIFO)。
队列结构如图 所示，队列中有 3 个元素，分别是 A、B 和 C，从在队列中的状态可以看出是 A 先进队列，然后 B 进，最后 C 进。根据“先进先出”的原则，3 个元素出队列的顺序应该是 A 最先出队列，然后 B 出，最后 C 出。
1.1.2 树存储结构
树存储结构适合存储具有“一对多”关系的数据。
如图所示，其中张平只有一个父亲，但他却有两（多）个孩子，这就是“一对多”的关系，满足这种关系的数据可以使用树存储结构。
1.1.3 图存储结构
图存储结构适合存储具有“多对多”关系的数据。
如图 所示，从 V1 可以到达 V2、V3、V4，同样，从 V2、V3、V4 也可以到达 V1，这就是“多对多”的关系，满足这种关系的数据可以使用图存储结构。
1.2 数据结构
数据结构从两个角度来说：
- 逻辑结构：简单地理解，就是指的数据之间的逻辑关系。
- 存储结构：也就是物理结构，指的是数据在物理存储空间上选择集中存放还是分散存放。
1.2.1 逻辑结构
数据之间的逻辑关系可细分为三类
-
一对一：类似集合
{1,2,3,...,n}这类的数据，每个数据的左侧有且仅有一个数据与其相邻（除 1 外）；同样，每个数据的右侧也只有一个数据与其相邻（除 n 外），所有的数据都是如此，就说数据之间是 一对一 的逻辑关系； -
一对多：图中的数据就属于“一对多”，因为对于张平来说，有且仅有一个父亲（张亮），但是有 2（多）个孩子；
-
多对多：拿下图来说，从 V1 可以到达 V2、V3、V4，同样，从 V2、V3、V4 也可以到达 V1，对于V1、V2、V3和V4来说，它们之间就是“多对多”的关系；
1.2.2 存储结构
如果选择集中存储，就使用顺序存储结构；反之，就使用链式存储。至于如何选择，主要取决于存储设备的状态以及数据的用途。
我们知道，集中存储（底层实现使用的是数组）需要使用一大块连续的物理空间，假设要存储大小为 1G 的数据，若存储设备上没有整块大小超过 1G 的空间，就无法使用顺序存储，此时就要选择链式存储，因为链式存储是随机存储数据，占用的都是存储设备中比较小的存储空间，因此有一定几率可以存储成功。
并且，数据的用途不同，选择的存储结构也不同。将数据进行集中存储有利于后期对数据进行遍历操作，而分散存储更有利于后期增加或删除数据。因此，如果后期需要对数据进行大量的检索（遍历），就选择集中存储；反之，若后期需要对数据做进一步更新（增加或删除），则选择分散存储。
1.3 如何衡量一个算法的好坏
在学习具体的数据结构和算法之前，每一位初学者都要掌握一个技能，即善于运用时间复杂度和空间复杂度来衡量一个算法的运行效率。
所谓算法，即解决问题的方法。同一个问题，使用不同的算法，虽然得到的结果相同，但耗费的时间和资源肯定有所差异。就比如拧一个螺母，扳手和钳子都可以胜任，但使用钳子拧螺母肯定没有扳手的效率高。
解决一个问题的方法可能有很多，但能称得上算法的，首先它必须能彻底解决这个问题（称为准确性），且根据其编写出的程序在任何情况下都不能崩溃（称为健壮性）。
注意，程序和算法是完全不同的概念。算法是解决某个问题的想法、思路；而程序是在根据算法编写出来的真正可以运行的代码。例如，要依次输出一维数组中的数据元素的值，首先想到的是使用循环结构，在这个算法的基础上，我们才开始编写程序。
在满足准确性和健壮性的基础上，还有一个重要的筛选条件，即通过算法所编写出的程序的运行效率。程序的运行效率具体可以从 2 个方面衡量，分别为：
- 程序的运行时间。
- 程序运行所需内存空间的大小。
根据算法编写出的程序，运行时间更短，运行期间占用的内存更少，该算法的运行效率就更高，算法也就更好。
那么，如何衡量一个算法所编写出程序的运行效率呢？数据结构中，用时间复杂度来衡量程序运行时间的多少；用空间复杂度来衡量程序运行所需内存空间的大小。
1.3.1 时间复杂度
判断一个算法所编程序运行时间的多少，并不是将程序编写出来，通过在计算机上运行所消耗的时间来度量。原因很简单，一方面，解决一个问题的算法可能有很多种，一一实现的工作量无疑是巨大的，得不偿失；另一方面，不同计算机的软、硬件环境不同，即便使用同一台计算机，不同时间段其系统环境也不相同，程序的运行时间很可能会受影响，严重时甚至会导致误判。
实际场景中，我们更喜欢用一个估值来表示算法所编程序的运行时间。所谓估值，即估计的、并不准确的值。注意，虽然估值无法准确的表示算法所编程序的运行时间，但它的得来并非凭空揣测，需要经过缜密的计算后才能得出。
也就是说，表示一个算法所编程序运行时间的多少，用的并不是准确值（事实上也无法得出），而是根据合理方法得到的预估值。
那么，如何预估一个算法所编程序的运行时间呢？很简单，先分别计算程序中每条语句的执行次数，然后用总的执行次数间接表示程序的运行时间。
以一段简单的 C 语言程序为例，预估出此段程序的运行时间：
for(int i = 0 ; i < n ; i++) //<- 从 0 到 n，执行 n+1 次
{
a++; //<- 从 0 到 n-1，执行 n 次
}
可以看到，这段程序中仅有 2 行代码，其中：
- for 循环从 i 的值为 0 一直逐增至 n（注意，循环退出的时候 i 值为 n），因此 for 循环语句执行了 n+1 次；
- 而循环内部仅有一条语句，a++ 从 i 的值为 0 就开始执行，i 的值每增 1 该语句就执行一次，一直到 i 的值为 n-1，因此，a++ 语句一共执行了 n 次。
因此，整段代码中所有语句共执行了 (n+1)+n 次，即 2n+1 次。数据结构中，每条语句的执行次数，又被称为该语句的频度。整段代码的总执行次数，即整段代码的频度。
再举一个例子：
for(int i = 0 ; i < n ; i++) // n+1
{
for(int j = 0 ; j < m ; j++) // n*(m+1)
{
num++; // n*m
}
}
读者可结合注释，计算此段程序的频度为：(n+1)+n(m+1)+nm，简化后得 2nm+2n+1。值得一提的是，不同程序的运行时间，更多场景中比较的是在最坏条件下程序的运行时间。以上面这段程序为例，最坏条件即指的是当 n、m 都为无限大时此段程序的运行时间。
要知道，当 n、m 都无限大时，我们完全就可以认为 n==m。在此基础上，2nm+2n+1 又可以简化为 \(2n^2+2n+1\)，这就是此段程序在最坏情况下的运行时间，也就是此段程序的频度。
如果比较以上 2 段程序的运行时间，即比较 2n+1 和 \(2n^2+2n+1\) 的大小，显然当 n 无限大时，前者要远远小于后者.
- 思考一个问题，类似 2n+1、2n2+2n+1 这样的频度，还可以再简化吗？答案是肯定的。
以 2n+1 为例，当 n 无限大时，是否在 2n 的基础上再做 +1 操作，并无关紧要，因为 2n 和 2n+1 当 n 无限大时，它们的值是无限接近的。甚至于我们还可以认为，当 n 无限大时，是否给 n 乘 2，也是无关紧要的，因为 n 是无限大，2*n 也是无限大。
再以无限大的思想来简化 2n2+2n+1。当 n 无限大的：
- 首先，常数 1 是可以忽略不计的；
- 其次，对于指数级的 2n2 来说，是否在其基础上加 2n，并无关紧要；
- 甚至于，对于是否给 n2 乘 2，也可以忽略。
因此，最终频度 2n2+2n+1 可以简化为 n2 。
得到最简频度的基础上，为了避免人们随意使用 a、b、c 等字符来表示运行时间，需要建立统一的规范。数据结构推出了大 O 记法（注意，是大写的字母 O，不是数字 0）来表示算法（程序）的运行时间。发展至今，此方法已为大多数人所采纳。
大 O 记法的表示方法也很简单，格式如下：O(频度),其中，这里的频度为最简之后所得的频度。
例如，用大 O 记法表示上面 2 段程序的运行时间，则上面第一段程序的时间复杂度为 O(n)，第二段程序的时间复杂度为 O(n2)。
如下列举了常用的几种时间复杂度，以及它们之间的大小关系：
O(1)常数阶 < O(logn)对数阶 < O(n)线性阶 < O(\(n^2\))平方阶 < O(\(n^3\))(立方阶) < O(\(2^n\)) (指数阶)
注意，这里仅介绍了以最坏情况下的频度作为时间复杂度，而在某些实际场景中，还可以用最好情况下的频度和最坏情况下的频度的平均值来作为算法的平均时间复杂度。
1.3.2 空间复杂度
和时间复杂度类似，一个算法的空间复杂度，也常用大 O 记法表示。
要知道每一个算法所编写的程序，运行过程中都需要占用大小不等的存储空间，例如：
- 程序代码本身所占用的存储空间；
- 程序中如果需要输入输出数据，也会占用一定的存储空间；
- 程序在运行过程中，可能还需要临时申请更多的存储空间。
首先，程序自身所占用的存储空间取决于其包含的代码量，如果要压缩这部分存储空间，就要求我们在实现功能的同时，尽可能编写足够短的代码。
程序运行过程中输入输出的数据，往往由要解决的问题而定，即便所用算法不同，程序输入输出所占用的存储空间也是相近的。
事实上，对算法的空间复杂度影响最大的，往往是程序运行过程中所申请的临时存储空间。不同的算法所编写出的程序，其运行时申请的临时存储空间通常会有较大不同。
举个例子：
int n;
scanf("%d", &n);
int a[10];
通过分析不难看出，这段程序在运行时所申请的临时空间，并不随 n 的值而变化。而如果将第 3 行代码改为：
int a[n];
此时，程序运行所申请的临时空间，和 n 值有直接的关联。
所以，如果程序所占用的存储空间和输入值无关，则该程序的空间复杂度就为 O(1)；反之，如果有关，则需要进一步判断它们之间的关系：
-
如果随着输入值 n 的增大，程序申请的临时空间成线性增长，则程序的空间复杂度用 O(n) 表示;
-
如果随着输入值 n 的增大，程序申请的临时空间成 \(n^2\) 关系增长，则程序的空间复杂度用 O(\(n^2\)) 表示；
-
如果随着输入值 n 的增大，程序申请的临时空间成$ n^3$ 关系增长，则程序的空间复杂度用 O(\(n^3\)) 表示；
在多数场景中，一个好的算法往往更注重的是时间复杂度的比较，而空间复杂度只要在一个合理的范围内就可以。
1.4 数据结构和算法的关系和区别
可以从分析问题的角度去理清数据结构和算法之间的关系。通常，每个问题的解决都经过以下两个步骤：
- 分析问题，从问题中提取出有价值的数据，将其存储；
- 对存储的数据进行处理，最终得出问题的答案；
数据结构负责解决第一个问题，即数据的存储问题。通过前面的学习我们知道，针对数据不同的逻辑结构和物理结构，可以选出最优的数据存储结构来存储数据。
而剩下的第二个问题，属于算法的职责范围。算法，从表面意思来理解，即解决问题的方法。我们知道，评价一个算法的好坏，取决于在解决相同问题的前提下，哪种算法的效率最高，而这里的效率指的就是处理数据、分析数据的能力。
因此我们得出这样的结论，
- 数据结构:用于解决数据存储问题
- 算法:是思考如何利用存储的数据快速无误地解决问题
例如，有这样一个问题，计算“1+2+3+4+5”的值。这个问题我们可以这样来分析：
- 计算 1、2、3、4 和 5 的和，首先要选择一种数据存储方式将它们存储起来，通过前面的学习我们知道，数据之间具有 一对一 的逻辑关系，最适合用线性表来存储。结合算法的实现，我们选择顺序表来存储数据（而不是链表），如图 1 所示；
- 接下来，我们选择算法。由于数据集中存放，因此我们可以设计这样一个算法，使用一个初始值为 0 的变量 num 依次同存储的数据做“加”运算，最后得到的新 num 值就是最终结果。
选择顺序表而不是链表的原因，是顺序表遍历数据比链表更高效。
二 线性表
2.1 什么是线性表
通过前面的学习我们知道，具有 一对一 逻辑关系的数据，最佳的存储方式是使用线性表。那么，什么是线性表呢？
线性表，全名为线性存储结构。使用线性表存储数据的方式可以这样理解，即“把所有数据用一根线儿串起来，再存储到物理空间中”。
将具有“一对一”关系的数据“线性”地存储到物理空间中，这种存储结构就称为线性存储结构（简称线性表）。
使用线性表存储的数据，如同向数组中存储数据那样，要求数据类型必须一致，也就是说，线性表存储的数据，要么全部都是整形，要么全部都是字符串。一半是整形，另一半是字符串的一组数据无法使用线性表存储。
2.1.1 线性表的存储结构
线性表存储结构可细分为顺序存储结构和链式存储结构。
- 顺序存储结构：将数据依次存储在连续的整块物理空间中，这种存储结构称为顺序存储结构（简称顺序表）
- 链式存储结构：数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系，这种存储结构称为链式存储结构（简称链表）；
2.1.2 前驱和后继
数据结构中，一组数据中的每个个体被称为“数据元素”（简称“元素”）
例如，上图显示的这组数据，其中 1、2、3、4 和 5 都是这组数据中的一个元素。
另外，对于具有“一对一”逻辑关系的数据，我们一直在用“某一元素的左侧（前边）或右侧（后边）”这样不专业的词，其实线性表中有更准确的术语：
- 某一元素的左侧相邻元素称为“直接前驱”，位于此元素左侧的所有元素都统称为“前驱元素”；
- 某一元素的右侧相邻元素称为“直接后继”，位于此元素右侧的所有元素都统称为“后继元素”；
以图 1 数据中的元素 3 来说，它的直接前驱是 2 ，此元素的前驱元素有 2 个，分别是 1 和 2；同理，此元素的直接后继是 4 ，后继元素也有 2 个，分别是 4 和 5。如图 所示：
2.2 顺序表
顺序表，全名顺序存储结构，是线性表的一种。通过《什么是线性表》一节的学习我们知道，线性表用于存储逻辑关系为“一对一”的数据，顺序表自然也不例外。
不仅如此，顺序表对数据的物理存储结构也有要求。顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。
由此我们可以得出，将“具有 '一对一' 逻辑关系的数据按照次序连续存储到一整块物理空间上”的存储结构就是顺序存储结构。
通过观察图 1 中数据的存储状态，我们可以发现，顺序表存储数据同数组非常接近。其实，顺序表存储数据使用的就是数组。
2.2.1 顺序表的初始化
使用顺序表存储数据之前，除了要申请足够大小的物理空间之外，为了方便后期使用表中的数据，顺序表还需要实时记录以下 2 项数据：
- 顺序表申请的存储容量；
- 顺序表的长度，也就是表中存储数据元素的个数；
提示：正常状态下，顺序表申请的存储容量要大于顺序表的长度。
因此，我们需要自定义顺序表，C 语言实现代码如下：
typedef struct Table{
int * head;//声明了一个名为head的长度不确定的数组，也叫“动态数组”
int length;//记录当前顺序表的长度
int size;//记录顺序表分配的存储容量
}table;
注意，head 是我们声明的一个未初始化的动态数组，不要只把它看做是普通的指针。
接下来开始学习顺序表的初始化，也就是初步建立一个顺序表。建立顺序表需要做如下工作：
- 给 head 动态数据申请足够大小的物理空间；
- 给 size 和 length 赋初值；
因此，C 语言实现代码如下：
#define Size 5 //对Size进行宏定义，表示顺序表申请空间的大小
table initTable(){
table t;
t.head=(int*)malloc(Size*sizeof(int));//构造一个空的顺序表，动态申请存储空间
if (!t.head) //如果申请失败，作出提示并直接退出程序
{
printf("初始化失败");
exit(0);
}
t.length=0;//空表的长度初始化为0
t.size=Size;//空表的初始存储空间为Size
return t;
}
我们看到，整个顺序表初始化的过程被封装到了一个函数中，此函数返回值是一个已经初始化完成的顺序表。这样做的好处是增加了代码的可用性，也更加美观。与此同时，顺序表初始化过程中，要注意对物理空间的申请进行判断，对申请失败的情况进行处理，这里只进行了“输出提示信息和强制退出”的操作，可以根据你自己的需要对代码中的 if 语句进行改进。
通过在主函数中调用 initTable 语句，就可以成功创建一个空的顺序表，与此同时我们还可以试着向顺序表中添加一些元素，C 语言实现代码如下：
#include <stdio.h>
#include <stdlib.h>
#define Size 5
typedef struct Table{
int * head;
int length;
int size;
}table;
table initTable(){
table t;
t.head=(int*)malloc(Size*sizeof(int));
if (!t.head)
{
printf("初始化失败");
exit(0);
}
t.length=0;
t.size=Size;
return t;
}
//输出顺序表中元素的函数
void displayTable(table t){
for (int i=0;i<t.length;i++) {
printf("%d ",t.head[i]);
}
printf("\n");
}
int main(){
table t=initTable();
//向顺序表中添加元素
for (int i=1; i<=Size; i++) {
t.head[i-1]=i;
t.length++;
}
printf("顺序表中存储的元素分别是：\n");
displayTable(t);
return 0;
}
程序运行结果如下：
顺序表中存储的元素分别是：
1 2 3 4 5
可以看到，顺序表初始化成功。
2.2.2 顺序表的基本操作
我们学习了顺序表及初始化的过程，本节学习有关顺序表的一些基本操作，以及如何使用 C 语言实现它们。
2.2.2.1 顺序表插入元素
向已有顺序表中插入数据元素，根据插入位置的不同，可分为以下 3 种情况：
- 插入到顺序表的表头；
- 在表的中间位置插入元素；
- 尾随顺序表中已有元素，作为顺序表中的最后一个元素；
虽然数据元素插入顺序表中的位置有所不同，但是都使用的是同一种方式去解决，即：通过遍历，找到数据元素要插入的位置，然后做如下两步工作：
- 将要插入位置元素以及后续的元素整体向后移动一个位置；
- 将元素放到腾出来的位置上。
