• 【C语言 - 数据结构】树、二叉树（上篇）

    树是计算机算法最重要的非线性结构。因为树能很好地描述结构的分支关系和层次特性，所以在计算机科学和计算机应用领域有着广泛的应用。这篇文章我就带大家一起了解一下树、二叉树这种结构，下篇文章会重点向大家介绍二叉树的遍历算法。

     如果人生值得活，那只是为了注视美。——柏拉图

    毫无疑问的是，树也是一种美丽的结构！

    文章目录

    • 1.树概念及结构
    • 2.二叉树概念及结构
    • 3.实现一种完全二叉树-堆，并实现堆排序
    • 4.Top-k问题
    • 总结

    提示：以下是本篇文章正文内容，下面案例可供参考

    一、树概念及结构

    1.1树的概念

    树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

     

     ·有一个特殊的结点，称为根结点，根节点没有前驱结点

    ·除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。

    ·每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 因此，树是递归定义的。

    注意：树形结构中，子树之间不能有交集，否则就不是树形结构

     1.2 树的相关概念

    节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6

    叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I...等节点为叶节点

    非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G...等节点为分支节点

    双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点

    孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点

    兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点

    树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6

    节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

    树的高度或深度：树中节点的最大层次； 如上图：树的高度为4

    堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点

    节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先

    子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙

    森林：由m（m>0）棵互不相交的树的集合称为森林；

    1.3 树的表示

    树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间 的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法 等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

    如下图所示：

     

    二、二叉树概念及结构

    2.1概念

    什么是二叉树？简言之一棵二叉树是结点的一个有限集合，该集合:

    1. 或者为空

    2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

    如下图示

     从上图我们可以看出二叉树的两个特点

    1. 二叉树不存在度大于2的结点

    2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

    注意：对于任意的二叉树都是由以下几种情况复合而成的：

    2.2 特殊的二叉树：

    1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是 说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。

    2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

    2.3 二叉树的性质

    1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2^(i - 1)个结点.

    2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h - 1 .

    3. 对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n1 ,则有n0 ＝n2 ＋1.

    4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n + 1) (是log以2 为底，n+1为对数)

    5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对 于序号为i的结点有：

    1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点.

    2.若2i+1<n, 左孩子序号；如果2i + 1 >=n 无左孩子

    3. 若2i+2<n, 右孩子序号；如果2i + 1 >=n 无右孩子

    解释：二叉树存储下标从0开始就会出现这种结果

    2.5 二叉树的存储结构

    1. 顺序存储

    顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空 间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺 序存储在物理上是一个数组，在逻辑上是一颗二叉树。

     2. 链式存储

    二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所 在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程 学到高阶数据结构如红黑树等会用到三叉链。

     

     三、实现一种完全二叉树-堆，并实现堆排序

    3.1堆的概念和结构

    如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足： = 且 >= ) i = 0，1， 2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

    堆的性质： 堆中某个节点的值总是不大于或不小于其父节点的值；

    堆总是一棵完全二叉树。

    3.2实现堆的难点：向上调整算法和向下调整算法

    由于堆是一种非线性存储结构，因此我们在执行堆的删除时会比较复杂，涉及到向下调整算法。

    1、原先我们在栈和队列那讲中的挪动数据覆盖根的位置的数据删除会导致堆的结构被破坏了，父子间的结构全乱了。

    向下调整算法的思路：

    1、第一个数（根位置）和最后一个位置进行交换。

    2、删除最后一个数据。

    3、找出左右孩子中小的那个和父亲比较，如果比父亲小，交换，再从交换的孩子位置继续往下调整。

    过程如下图所示：

    1. 向下调整算法
    2. void* AdjustDown(HPDataType* a, size_t size, size_t root)
    3. {
    4.        size_t parent = root;
    5.        size_t child = parent * 2 + 1;//默认是左孩子
    6.        while (child < size)
    7.        {
    8.               //1、选出左右孩子中小的那个，而且保证不会越界访问
    9.               if (child + 1 < size && a[child + 1] < a[child])
    10.               {
    11.                       child++;//左孩子变为右孩子
    12.               }
    13.               if (a[child]< a[parent])
    14.               {
    15.                       Swap(&a[child], &a[parent]);
    16.                       parent = child;//继续计算
    17.                       child = parent * 2 + 1;//默认还是计算左孩子
    18.               }
    19.               else
    20.               {
    21.                       break;
    22.               }
    23.        }
    24. }

     为了保持堆的结构，我们还要引入向上调整算法，由于两种算法原理差不多而且向上调整比较简单易懂，我直接上代码了。

    1. void Adjustup(HPDataType* a, size_t child)
    2. {
    3.        size_t parent = (child - 1) / 2;
    4.        while (child > 0)
    5.        {
    6.               //小堆a[child] <a[parent],大堆a[child] > a[parent]时交换
    7.               if (a[child] < a[parent])
    8.               {
    9.                       Swap(&a[child], &a[parent]);//因为是指针传参，所以要&
    10.                       child = parent;
    11.                       parent = (child - 1) / 2;
    12.               }
    13.               else
    14.               {
    15.                       break;
    16.               }
    17.        }
    18. }

     

    3.3小堆的实现

    头文件：

    1. #pragma once
    2.  
    3. // 小堆
    4. #include<stdio.h>
    5. #include<assert.h>
    6. #include<stdlib.h>
    7. #include<stdbool.h>
    8.  
    9. typedef int HPDataType;
    10. typedef struct Heap
    11. {
    12. 	HPDataType* a;
    13. 	size_t size;
    14. 	size_t capacity;
    15. }HP;
    16. void PrintTopk(int* a, int n, int k);
    17. void HeapInit(HP* php);//堆的初始化
    18. void HeapDestory(HP* php);//堆的销毁
    19. void Swap(HPDataType* pa, HPDataType* pb);//交换
    20. void HeapPrint(HP* php);
    21. void AdjustDown(HPDataType* a, size_t size, size_t root);//堆的向下调整算法
    22. //插入x以后，依旧保持堆
    23. void HeapPush(HP* php, HPDataType x);
    24. void Adjustup(HPDataType* a, size_t child);//堆的向上调整算法
    25. //删除堆顶的数据，（最小/最小）
    26. void HeapPop(HP* php);
    27.  
    28. bool HeapEmpty(HP* php);
    29. size_t HeapSize(HP* php);
    30. HPDataType HeapTop(HP* php);

    源文件：

    1. #include"Heap.h"
    2.  
    3. void HeapInit(HP* php)
    4. {
    5. 	assert(php);
    6. 	php->a = NULL;
    7. 	php->size = php->capacity = 0;
    8. }
    9. void HeapDestory(HP* php)
    10. {
    11. 	assert(php);
    12. 	free(php->a);
    13. 	php->a = NULL;
    14. 	php->size = php->capacity = 0;
    15.  
    16. }
    17. void Swap(HPDataType* pa, HPDataType* pb)
    18. {
    19. 	HPDataType tmp = *pa;
    20. 	*pa = *pb;
    21. 	*pb = tmp;
    22. }
    23. void HeapPrint(HP* php)
    24. {
    25. 	assert(php);
    26. 	for (size_t i = 0; i < php->size; i++)
    27. 	{
    28. 		printf("%d ", php->a[i]);
    29. 	}
    30. 	printf("\n");
    31. }
    32. //涉及堆排序
    33. void Adjustup(HPDataType* a, size_t child)
    34. {
    35. 	size_t parent = (child - 1) / 2;
    36. 	while (child > 0)
    37. 	{
    38. 		//小堆a[child] <a[parent],大堆a[child] > a[parent]时交换
    39. 		if (a[child] < a[parent])
    40. 		{
    41. 			Swap(&a[child], &a[parent]);//因为是指针传参，所以要&
    42. 			child = parent;
    43. 			parent = (child - 1) / 2;
    44. 		}
    45. 		else
    46. 		{
    47. 			break;
    48. 		}
    49. 	}
    50. }
    51. void AdjustDown(HPDataType* a, size_t size, size_t root)
    52. {
    53. 	size_t parent = root;
    54. 	size_t child = parent * 2 + 1;//默认是左孩子
    55. 	while (child < size)
    56. 	{
    57. 		//1、选出左右孩子中小的那个，而且保证不会越界访问
    58. 		if (child + 1 < size && a[child + 1] < a[child])//建大堆时< 改 >
    59. 		{
    60. 			++child;//左孩子变为右孩子
    61. 		}
    62. 		if (a[child] < a[parent])//建大堆时< 改 >
    63. 		{
    64. 			Swap(&a[child], &a[parent]);
    65. 			parent = child;//继续计算
    66. 			child = parent * 2 + 1;//默认还是计算左孩子
    67. 		}
    68. 		else
    69. 		{
    70. 			break;
    71. 		}
    72. 	}
    73. }
    74.  
    75. void HeapPush(HP* php, HPDataType x)
    76. {
    77. 	assert(php);
    78.  
    79. 	if (php->size == php->capacity)//满了，需要扩容
    80. 	{
    81. 		size_t newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    82. 		//翻译：新定义一个无符号的newCapacity = 原来的capacity，如果原来的capacity = 0, 就赋值为4，4不够就再*二倍
    83. 		HPDataType* tmp = realloc(php->a, sizeof(HPDataType)* newCapacity);
    84. 		if (tmp == NULL)
    85. 		{
    86. 			printf("reallpc failed\n");
    87. 			exit(-1); 
    88. 		}
    89. 		php->a = tmp;
    90. 		php->capacity = newCapacity;
    91. 	}
    92. 	//尾插
    93. 	php->a[php->size] = x;
    94. 	++php->size;
    95. 	//向上调整保持是一个小堆
    96. 	Adjustup(php->a, php->size - 1);
    97. }
    98. void HeapPop(HP* php)
    99. {
    100. 	assert(php);
    101. 	assert(php->size > 0);
    102. 	Swap(&php->a[0], &php->a[php->size - 1]);
    103. 	--php->size;
    104. 	AdjustDown(php->a, php->size, 0);
    105. }
    106. bool HeapEmpty(HP* php)
    107. {
    108. 	assert(php);
    109. 	return php->size == 0;
    110. }
    111. size_t HeapSize(HP* php)
    112. {
    113. 	return php->size;
    114. }
    115. HPDataType HeapTop(HP* php)
    116. {
    117. 	return php->a[0];
    118. }

     3.4 堆的应用 ： 堆排序

    堆排序即利用堆的思想来进行排序，总共分为两个步骤：

    1. 建堆 升序：建大堆

               .降序：建小堆

    2. 利用堆删除思想来进行排序 建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

    代码示例：

    1. void AdjustDown(HPDataType* a, size_t size, size_t root)
    2. {
    3.        size_t parent = root;
    4.        size_t child = parent * 2 + 1;//默认是左孩子
    5.        while (child < size)
    6.        {
    7.               //1、选出左右孩子中小的那个，而且保证不会越界访问
    8.               if (child + 1 < size && a[child + 1] <a[child])//建大堆时< 改 >
    9.               {
    10.                       ++child;//左孩子变为右孩子
    11.               }
    12.               if (a[child] < a[parent])//建大堆时< 改 >
    13.               {
    14.                       Swap(&a[child], &a[parent]);
    15.                       parent = child;//继续计算
    16.                       child = parent * 2 + 1;//默认还是计算左孩子
    17.               }
    18.               else
    19.               {
    20.                       break;
    21.               }
    22.        }
    23. }
    24. void HeapSort2(int* a, int n)
    25. {
    26. 	//向上调整--建堆
    27. 	//for (int i = 1; i < n; ++i)
    28. 	//{
    29. 	//	AdjustUp(a, i);
    30. 	//}
    31. 	//向下调整--建堆O（N）
    32. 	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
    33. 	{
    34. 		AdjustDown(a, n, i);//为什么向下调整要多传一个参数，因为当child>=size 时说明已经到了边界
    35. 	}
    36. 	size_t end = n - 1;//n - 1是最后一个数据的下标
    37. 	while (end > 0)
    38. 	{
    39. 		Swap(&a[0], &a[end]);
    40. 		AdjustDown(a, end, 0);
    41. 		//次大的数到了倒数第二个位置
    42. 		--end;
    43. 	}
    44. }
    45. int main()
    46. {
    47. //	TestHeap();
    48. 	int a[] = { 4 , 2, 7, 8, 5, 1, 0, 6 };
    49. 	HeapSort(a, sizeof(a) / sizeof(int));
    50. 	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    51. 	{
    52. 		printf("%d ", a[i]);
    53. 	}
    54. 	printf("\n");
    55. 	return 0;
    56. }

     

     四.Top-k问题

    TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

    比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

    对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能 数据都不能一下子全部加载到内存中)。

    最佳的方式就是用堆来解决，基本思路如下：

    1. 用数据集合中前K个元素来建堆 前k个最大的元素，则建小堆 前k个最小的元素，则建大堆 2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素。

    将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

     因为N非常大，k非常小，所以复杂度相当于0（N）

    设置10个比100万大的数，然后让电脑随机生成数，找出大于100万的10个数。

    1. void PrintTopk(int* a, int n, int k)
    2. {
    3. 	//1、建堆-- 用a中前k个元素建堆
    4. 	int* kminHeap = (int*)malloc(sizeof(int)* k);
    5. 	assert(kminHeap);
    6. 	//2、将剩余n-k元素依次与堆顶元素交换，不满则替换
    7.  
    8. 	for (int i = 0; i < k; i++)
    9. 	{
    10. 		kminHeap[i] = a[i];//将前k个数给给它
    11. 	}
    12. 	//第k-1个是最后一位数的下标，(k - 1 -1) / 2是倒数第一个非叶子结点
    13. 	//建小堆
    14. 	for (int j = (k - 1 - 1) / 2; j >= 0; --j)
    15. 	{
    16. 		AdjustDown(kminHeap, k, j);
    17. 	}
    18. 	//2、将剩余n - k元素依次与堆顶元素交换，不满则替换
    19. 	for (int i = k; i < n; ++i)
    20. 	{
    21. 		if (a[i] > kminHeap[0])
    22. 		{
    23. 			kminHeap[0] = a[i];
    24. 			AdjustDown(kminHeap, k, 0);//从根这个点向下调
    25. 		}
    26. 	}
    27. 	for (int j = 0; j < k; j++)
    28. 	{
    29. 		printf("%d ", kminHeap[j]);
    30. 	}
    31. 	printf("\n");
    32. 	free(kminHeap);
    33.  
    34. }
    35. void TestTopk()
    36. {
    37. 	int n = 10000;
    38. 	int* a = (int*)malloc(sizeof(int)* n);
    39. 	srand(time(0));
    40. 	for (size_t i = 0; i < n; ++i)
    41. 	{
    42. 		a[i] = rand() % 1000000;
    43. 	}
    44. 	a[5] = 1000000 + 1;
    45. 	a[1231] = 1000000 + 2;
    46. 	a[531] = 1000000 + 3;
    47. 	a[5121] = 1000000 + 4;
    48. 	a[115] = 1000000 + 5;
    49. 	a[2305] = 1000000 + 6;
    50. 	a[99] = 1000000 + 7;
    51. 	a[76] = 1000000 + 8;
    52. 	a[423] = 1000000 + 9;
    53. 	a[0] = 1000000 + 1000;
    54. 	PrintTopk(a, n, 10);
    55. }
    56. int main()
    57. {
    58. 	TestTopk();
    59.  
    60. 	return 0;
    61. }

    总结

             本文近7500字，主要从树以及二叉树的概念和结构展开详讲，再详细介绍了堆（特殊的二叉树）这种数据结构的概念、原理以及实现，还有堆的重要应用：堆排序以及TOPK问题等，希望大家读后能够有所收获。

  • 相关阅读:
    k8s中的Controller
    我的创作纪念日
    WPF创建自定义控件编译通过但是找不到资源
    Stacked Hourglass Networks for Human Pose Estimation 源码分析
    Redis数据类型-String-基本使用和原理
    CCF CSP认证 历年题目自练Day24
    基于vue3和element-plus的省市区级联组件
    基于MATLAB的高阶(两个二阶级联构成的四阶以及更高阶)数字图形音频均衡器系数计算(可直接用于DSP实现)
    LeetCode 2316. 统计无向图中无法互相到达点对数：：广度优先搜索（BFS）
    【学习笔记】子集和问题
  • 原文地址：https://blog.csdn.net/qq_62662919/article/details/124954369