（数据结构）二叉树
树
概念与结构
树是⼀种非线性的数据结构，它是由 n（n>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，而叶朝下的。
特点：
- 有⼀个特殊的结点，称为根结点，根结点没有前驱结点。
- 除根结点外，其余结点被分成 M(M>0) 个互不相交 的集合 T1、T2、......、Tm ，其中每⼀个集合Ti(1 <= i <= m) 又是⼀棵结构与树类似的子树。每棵子树的根结点有且只有⼀个前驱，可以有 0 个或多个后继。因此，树是递归定义的。
- 树形结构中，子树之间不能有交集，否则就不是树形结构
• 子树是不相交的（如果存在相交就是图）
• 除了根结点外，每个结点有且仅有⼀个⽗结点
• ⼀棵N个结点的树有N-1条边
非树形结构：
相关术语
- 父结点/双亲结点：若⼀个结点含有子结点，则这个结点称为其⼦结点的父结点； 如上图：A是B的父结点
- 子结点/孩子结点：⼀个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
- 结点的度：⼀个结点有几个孩子/子结点，他的度就是多少；比如A的度为6，F的度为2，K的度为0
- 树的度：⼀棵树中，最大的结点的度称为树的度； 如上图：树的度为 6
- 叶子结点/终端结点：度为 0 的结点称为叶结点； 如上图： B、C、H、I... 等结点为叶结点
- 分支结点/非终端结点：度不为 0 的结点； 如上图： D、E、F、G... 等结点为分支结点
- 兄弟结点：具有相同父结点的结点互称为兄弟结点(亲兄弟)； 如上图： B、C 是兄弟结点
- 结点的层次：从根开始定义起，根为第 1 层，根的子结点为第 2 层，以此类推；
树的高度或深度：树中结点的最大层次； 如上图：树的高度为 4 - 结点的祖先：从根到该结点所经分支上的所有结点；如上图： A 是所有结点的祖先
路径：⼀条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列；比如A到Q的路径为：A-E-J-Q；H到Q的路径H-D-A-E-J-Q （每两个结点之间的路径是唯一的） - 子孙：以某结点为根的子树中任⼀结点都称为该结点的子孙。如上图：所有结点都是A的子孙
森林：由 m（m>0） 棵互不相交的树的集合称为森林；
数的表示
孩子兄弟表示法：
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法
c
struct TreeNode
{
struct Node* child; // 左边开始的第⼀个孩⼦结点
struct Node* brother; // 指向其右边的下⼀个兄弟结点
int data; // 结点中的数据域
};
------通过这个方法可以覆盖到树的所有结点
树的实际应用场景
文件系统是计算机存储和管理文件的⼀种方式，它利用树形结构来组织和管理文件和文件夹。在文件系统中，树结构被广泛应用，它通过父结点和子结点之间的关系来表示不同层级的文件和文件夹之间的关联。
二叉树
概念与结构
在树形结构中，我们最常用的就是二叉树，⼀棵二叉树是结点的⼀个有限集合，该集合由⼀个根结点加上两棵分别称为左子树和右子树的二叉树组成或者为空。
从上图可以看出二叉树具备以下特点：
- 二叉树不存在度大于 2 的结点（度只可能为0、1、2）
- 二叉树的子树有左右之分 ，次序不能颠倒，因此二叉树是有序树。
注意：对于任意的二叉树都是由以下几种情况复合而成的。
特殊的二叉树
满二叉树
⼀个二叉树，如果每⼀个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果⼀个二叉树的层数为 K，且结点总数是 2^k − 1，则它就是满二叉树。
完全二叉树
完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为 K 的，有 n 个结点的二叉树，当且仅当其每⼀个结点都与深度为K的满二叉树中编号从 1 至 n 的结点⼀⼀对应时称之为完全二叉树。
其主要特点如下：
-
除了最后一层，其他每层结点个数都达到了最大（和满二叉树完全一样）。最后一层结点个数不一定达到最大。
-
- 最后一层结点从左到右依次排列。
满二叉树是⼀种特殊的完全二叉树。
满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。
- 最后一层结点从左到右依次排列。
-
注：二叉树的性质
根据满二叉树的特点可知：
- 若规定根结点的层数为 1 ，则⼀棵非空二叉树的第 i 层上最多有 2^(i−1) 个结点
- 若规定根结点的层数为 1 ，则深度为 h 的⼆叉树的最大结点数是 2^h - 1
- 若规定根结点的层数为 1 ，具有 n 个结点的满二叉树的深度 log2 （n+1）
（log以2为底， n+1 为对数)
（由2.可以推导出来）
二叉树的存储结构
⼆叉树⼀般可以使用两种结构存储，一种顺序结构，一种链式结构。
顺序结构
顺序结构存储就是使用数组来存储，⼀般使用数组只适合表示完全二叉树 ，因为不是完全二叉树会有空间的浪费，完全二叉树更适合使用顺序结构存储。
现实中我们通常把堆（⼀种二叉树）使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的⼀块区域分段。
链式结构
二叉树的链式存储结构是指，用链表来表示⼀棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是：链表中每个结点由三个域组成，分别为数据域和左右指针域，左右指针分别用来存储该结点左孩子和右孩
子所在的链结点的存储地址 。
链式结构又分为二叉链和三叉链。
实现顺序结构二叉树
堆的概念与结构
简单来说，堆分为两种，一种是小堆/小根堆，堆顶（根结点）是堆里最小的数据，每个父结点都小于等于其子结点；一种是大堆/大根堆，堆顶（根结点）是堆里最大的数据，每个父结点都大于等于其子结点。
综上，总结堆有以下性质：
-
堆中某个结点的值总是不大于或不小于其父结点的值；
-
堆总是一棵完全二叉树。
-
注：二叉树性质
对于具有 n 个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从
0 开始编号，则对于序号为 i 的结点有：
- 由子结点可求父结点 ：
若 i>0（根结点外的其他结点） ， 则i 位置结点的父结点序号为： (i-1)/2 （结果若为分数则下取整）；
若 i=0 （根结点）， i 为根结点编号，无双亲结点 - 由父结点可求子结点
- 若 2i+1<n ，左孩子序号： 2i+1
若 2i+1>=n， 则无左孩子 - 若 2i+2<n ，右孩子序号： 2i+2
若 2i+2>=n， 则无右孩子
（以下是编号从1开始的规律）
堆的实现
初始化
c
void HPInit(HP* php)
{
assert(php);
php->arr = NULL;
php->size = php->capacity = 0;
}销毁
c
void HPDestroy(HP* php)
{
assert(php);
if (php->arr) {
free(php->arr);
php->arr = NULL;
}
php->size = php->capacity = 0;
}入堆
- 判断空间是否足够
- 插入元素
- 调整堆（根据原本的堆是大堆还是小堆）
------利用向上调整 算法（已知child求parent）
c
void Swap(HPDataType* left, HPDataType* right)
{
HPDataType tmp = *left;
*left = *right;
*right = tmp;
}
void AdjustUp(HPDataType* arr, int child) {
int parent = (child - 1) / 2;
while (child > 0)
{
if (arr[child] < arr[parent])//小堆< 大堆>
{
Swap(&arr[child], &arr[parent]);
child = parent;
parent = (child - 1) / 2;
}
else {
break;
}
}
}
void HPPush(HP* php, HPDataType x) {
assert(php);
//检查容量，必要时增容
if (php->size == php->capacity)
{
int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
HPDataType* tmp = (HPDataType*)realloc(php->arr, newCapacity * sizeof(HPDataType));
if (tmp == NULL) {
perror("realloc fail!");
exit(1);
}
php->arr = tmp;
php->capacity = newCapacity;
}
//插入数据
php->arr[php->size] = x;
//向上调整
AdjustUp(php->arr, php->size);
php->size++;
}出堆
"出堆"出的是堆顶数据
- 探空
- 栈顶和堆最后一个数据交换 size--
（如果直接把数组第一个数据出堆再让其它数据前移，会让整个堆的数据变得混乱，难以重组，但是如果进行这样的交换，只需要再把新的堆顶进行一次调整） - 向下调整
c
bool HPEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
void AdjustDown(HPDataType* arr, int parent, int n)
{
//获得左孩子结点(注意child相当于动态的指针）
int child = 2 * parent + 1;
while (child < n) {
//先比较两个子结点谁更大，注意先要判断有没有右结点（防止越界）
if (child+1<n && arr[child] > arr[child + 1]) {
child++;//（小堆）直接切换到小的子结点向下遍历即可
}
if (arr[parent] > arr[child]) //小堆> 大堆<
{
Swap(&arr[parent], &arr[child]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
void HPPop(HP* php)
{
//探空
assert(!HPEmpty(php));
//出堆
Swap(&php->arr[0], &php->arr[php->size - 1]);
php->size--;
//向下调整
AdjustDown(php->arr,0,php->size );
}取堆顶
c
HPDataType HPTop(HP* php) {
assert(!HPEmpty(php));
return php->arr[0];
}- 循环取堆顶：可以输出降序数列
c
while(!HPEmpty(&hp))
{
int top=HPTop(&hp);
printf("%d ",top)；
HPPop(&hp);
}堆的应用
堆排序
由上方循环取堆顶的操作，我们发现堆有一种排序的功能，基于此功能的启发，我们继续实现堆排序。
c
//堆排序1-借助数据结构堆来实现
void HeapSort01(int* arr, int n) {
HP hp;
HPInit(&hp);
//用数组数据建堆
for (int i = 0;i < n;i++) {
HPPush(&hp, arr[i]);
}
int i = 0;
while (!HPEmpty(&hp))
{
int top = HPTop(&hp);
arr[i++] = top;
HPPop(&hp);
}
HPDestroy(&hp);
}
//堆排序2-借助堆的思想排序，不需要构建堆的数据结构
//从下到上调整
void HeapSort02(int* arr, int n)
{
//建堆：向下调整
//从最后一个结点的父亲开始调整（也就是从最后一棵子树开始，计算方法用小树理解）
for (int i = (n - 1 - 1) / 2;i >= 0;i--)
{
AdjustDown(arr, i, n);
}
//实现堆排序
//1.把首尾元素交换 2.end前移，对覆盖的范围重新调整成堆
int end = n - 1;
while (end > 0)
{
Swap(&arr[0], &arr[end]);
AdjustDown(arr, 0, end);
end--;
}
}
//问题：为什么需要从中间向下调整？
/*关键原因：向下调整的前提是左右子树已经是堆
当使用向下调整（AdjustDown）建堆时，必须从最后一个非叶子节点开始向前调整：
叶子节点（没有子节点）本身就是堆，无需调整
(n-1-1)/2 计算的是最后一个节点的父节点索引，即最后一个非叶子节点
从后往前调整，可以保证调整当前节点时，其左右子树已经是合法的堆结构
*/
//时间复杂度n*log(n)
//交换要进行n-1次，向下调整算法的时间复杂度是堆的高度
//堆排序3-借助堆的思想排序，不需要构建堆的数据结构
//向上调整建堆
void HeapSort03(int* arr, int n)
{
//建堆：向上调整
for (int i = 0 ;i < n ;i++)
{
AdjustUp(arr, i);
}
//实现堆排序
//1.把首尾元素交换 2.end前移，对覆盖的范围重新调整成堆
int end = n - 1;
while (end > 0)
{
Swap(&arr[0], &arr[end]);
AdjustDown(arr, 0, end);
end--;
}
}- 讨论：向下调整与向上调整建堆的时间复杂度
- 向下调整算法
- 向上调整算法
计算后发现向下调整算法时间复杂度小于向上调整算法。
TOP-K问题
TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
1）用数据集合中前K个元素来建堆
前k个最大的元素，则建小堆
前k个最小的元素，则建大堆
2）用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
建小堆：比堆顶数据大就入堆，堆顶是最小值的界限
建大堆：比堆顶数据小就入堆，堆顶是最大值的界限
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素
示例代码
c
//TOPK
void CreateNDate()
{
// 造数据
int n = 100000;
srand(time(0));
const char* file = "data.txt";
FILE* fin = fopen(file, "w");
if (fin == NULL)
{
perror("fopen error");
return;
}
for (int i = 0; i < n; ++i)
{
int x = (rand() + i) % 1000000;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
void Topk()
{
int k = 0;
printf("请输入K：");
scanf("%d", &k);
const char* file = "data.txt";
FILE* fout = fopen(file, "r");
if (fout == NULL)
{
perror("fopen error");
exit(1);
}
//找最大的前K个数据，建小堆
int* minHeap = (int*)malloc(sizeof(int) * k);
if (minHeap == NULL)
{
perror("malloc fail!");
exit(2);
}
for (int i = 0; i < k; i++)
{
fscanf(fout, "%d", &minHeap[i]);
}
//建堆--向下调整建堆
for (int i = (k - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(minHeap, i, k);
}
//遍历剩下的n-k个数，跟堆顶进行比较，谁大谁入堆
//调整堆
int x = 0;
while (fscanf(fout, "%d", &x) != EOF)
{
if (x > minHeap[0])
{
minHeap[0] = x;
AdjustDown(minHeap, 0, k);
}
}
for (int i = 0; i < k; i++)
{
printf("%d ", minHeap[i]);
}
fclose(fout);
}
//时间复杂度k+(n-k)log2k