• 二叉树的实现

    > 作者简介：დ旧言~，目前大一，现在学习Java，c，c++，Python等
    > 座右铭：松树千年终是朽，槿花一日自为荣。

    > 目标：掌握二叉树，掌握二叉树的顺序存储和链式存储。

    > 毒鸡汤：要想青春不留遗憾，小伙必须敢想敢干。
    > 望小伙伴们点赞👍收藏✨加关注哟💕💕 

    🌟前言 

            谈起二叉树，就不得不谈起树，此时坐在小板凳上的小伙伴们，纷纷举手说，这个我懂。开心的不得了，博主表示你们认知的树，小盆友都懂，😅😅。我们谈的是数据结构的树。

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

     就像右图，A点就头，其它就像根，长的真丑，😉😉，当然啦，直接给个树给你，都不知道有啥用，咱就介绍一下数据结构中的树相关知识，话不多说。

    ⭐主体   

    🌙树概念及结构

    🌝树的相关概念

    节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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. //定义数据类型
    2. typedef int HPDataType;
    3.  
    4. //二叉树堆的实现
    5. typedef struct Heap
    6. {
    7. 	//下一个节点
    8. 	HPDataType* a;
    9. 	//元素个数
    10. 	int size;
    11. 	//初始化个数
    12. 	int capacity;
    13. }HP;

    🌙二叉树（重点 ）

     

            看到上面的树，想必大家耳熟能详，有一部分小伙伴学习这个知识点，头都是大的，最讨厌里面的递归，直接把人干蒙了。不过有本宝宝在，不怕不怕😎

    🌝二叉树概念及结构

    从上图可以看出：
    💦1. 二叉树不存在 度大于2的 结点
    💦2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
    💤特殊的二叉树

    满二叉树：

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

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

    1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 个结点.
    2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 .
    3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有 n0＝ n1＋1
    4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= . (ps： 是log以2
    为底，n+1为对数)
    5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
            💦1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
            💦2. 若2^i+1左孩子序号：2^i+1，2i+1>=n否则无左孩子
            💦3. 若2^i+2右孩子序号：2^i+2，2i+2>=n否则无右孩子

    🌝二叉树的顺序存储结构

           普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

    因此这里有关于二叉树的堆的存储，我们来看看堆的存储方式如何实现。

    💫主体

    咱们从三个方面实现二叉树的堆，动态管理，建小大堆，对元素进行操作。

    在程序中为了实现二叉树的堆，需要创建头文件Heap.h ，创建源文件Heap.c，主函数Test.c

     🌠动态管理
    💤初始化动态二叉树的堆

    1.首先我们在Heap.h定义动态的二叉树的堆，省得我们再调用（堆），这里和链表是一样哒。

    1. //定义数据类型
    2. typedef int HPDataType;
    3.  
    4. //二叉树堆的实现
    5. typedef struct Heap
    6. {
    7. 	//下一个节点
    8. 	HPDataType* a;
    9. 	//元素个数
    10. 	int size;
    11. 	//初始化个数
    12. 	int capacity;
    13. }HP;

     2.对堆进行初始化。

    1. //初始化
    2. void HeapInit(HP* php) 
    3. {
    4. 	//断言
    5. 	assert(php);
    6. 	//初始化
    7. 	php->a = NULL;
    8. 	php->size = 0;
    9. 	php->capacity = 0;
    10. }

    3.建立二叉树。

    1. //建立二叉树
    2. void HeapInitArray(HP* php, int* a, int n)
    3. {
    4. 	//断言
    5. 	assert(php);
    6. 	assert(a);
    7. 	//开辟空间
    8. 	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    9. 	//判断
    10. 	if (php->a == NULL)
    11. 	{
    12. 		perror("malloc fail");
    13. 		exit(-1);
    14. 	}
    15. 	//赋值
    16. 	php->size = n;
    17. 	php->capacity = n;
    18. 	//把a的元素拷贝的开辟的二叉树中
    19. 	memcpy(php->a, a, sizeof(HPDataType) * n);
    20. 	// 建堆
    21. 	for (int i = 1; i < n; i++)
    22. 	{
    23. 		//向上调整建小堆 实现取出最小的元素（后面会实现）
    24. 		AdjustUp(php->a, i);
    25. 	}
    26. }
    💤释放堆内存
    1. //销毁
    2. void HeapDestroy(HP* php)
    3. {
    4. 	//断言
    5. 	assert(php);
    6. 	//释放内存
    7. 	free(php->a);
    8. 	php->a = NULL;
    9. 	php->size = php->capacity = 0;
    10. }
     🌠建大小堆
    💤实现向上调整建小堆
    1. //实现向上调整建小堆
    2. void AdjustUp(HPDataType* a, int child)
    3. {
    4. 	//父亲和孩子的关系
    5. 	int parent = (child - 1) / 2;
    6. 	while (child > 0)
    7. 	{
    8. 		//实现向上调整元素
    9. 		if (a[child] < a[parent])
    10. 		{
    11. 			Swap(&a[child], &a[parent]);
    12. 			child = parent;
    13. 			parent = (parent - 1) / 2;
    14. 		}
    15. 		else
    16. 		{
    17. 			break;
    18. 		}
    19. 	}
    20. }
    💤实现向下调整建大堆
    1. //实现向下调整建大堆
    2. void AdjustDown(HPDataType* a, int n, int parent)
    3. {
    4. 	//孩子和父亲的关系 
    5. 	int child = parent * 2 + 1;
    6. 	while (child < n)
    7. 	{
    8. 		//找出小的那个孩子
    9. 		if (child + 1 < n && a[child + 1] < a[child])
    10. 		{
    11. 			++child;
    12. 		}
    13. 		//实现向下调整元素
    14. 		if (a[child] < a[parent])
    15. 		{
    16. 			Swap(&a[child], &a[parent]);
    17. 			// 继续往下调整
    18. 			parent = child;
    19. 			child = parent * 2 + 1;
    20. 		}
    21. 		else
    22. 		{
    23. 			break;
    24. 		}
    25. 	}
    26. }
     🌠元素操作
    💤打印元素
    1. //打印元素
    2. void HeapPrint(HP* php)
    3. {
    4. 	//断言
    5. 	assert(php);
    6.  
    7. 	for (size_t i = 0; i < php->size; i++)
    8. 	{
    9. 		printf("%d ", php->a[i]);
    10. 	}
    11. 	printf("\n");
    12. }
    💤添加元素
    1. //添加元素
    2. void HeapPush(HP* php, HPDataType x)
    3. {
    4. 	//断言
    5. 	assert(php);
    6. 	//扩容（这里实现元素一个添加在堆中）
    7. 	//（需要主函数整个循环）
    8. 	if (php->size == php->capacity)
    9. 	{
    10. 		//实现扩容
    11. 		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    12. 		//开辟空间
    13. 		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newCapacity);
    14. 		//判断
    15. 		if (tmp == NULL)
    16. 		{
    17. 			perror("realloc fail");
    18. 			exit(-1);
    19. 		}
    20.  
    21. 		php->a = tmp;
    22. 		php->capacity = newCapacity;
    23. 	}
    24.  
    25. 	php->a[php->size] = x;
    26. 	php->size++;
    27. 	//添加元素后实现向上调整 建成小堆
    28. 	AdjustUp(php->a, php->size - 1);
    29. }
    💤删除元素
    1. //删除元素（这里可以实现排序 （从小到大） ）
    2. void HeapPop(HP* php)
    3. {
    4. 	//断言
    5. 	assert(php);
    6. 	assert(php->size > 0);
    7. 	
    8. 	//第一个元素和最后一个元素交换
    9. 	Swap(&php->a[0], &php->a[php->size - 1]);
    10. 	--php->size;
    11. 	
    12. 	//向下调整后 就可以剥离出最后一个元素实现排序（小到大）
    13. 	AdjustDown(php->a, php->size, 0);
    14. }
    💤返回第一个元素
    1. //返回第一个元素
    2. HPDataType HeapTop(HP* php)
    3. {
    4. 	//断言
    5. 	assert(php);
    6. 	assert(php->size > 0);
    7. 	//返回第一个元素
    8. 	return php->a[0];
    9. }
    💤判断不能没有元素
    1. //判断不能没有元素
    2. bool HeapEmpty(HP* php)
    3. {
    4. 	//断言
    5. 	assert(php);
    6. 	//
    7. 	return php->size == 0;
    8. }
    🪐代码总结
    🌠Heap.h头文件
    1. //包含头文件
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8.  
    9. //定义数据类型
    10. typedef int HPDataType;
    11.  
    12. //二叉树堆的实现
    13. typedef struct Heap
    14. {
    15. 	//下一个节点
    16. 	HPDataType* a;
    17. 	//元素个数
    18. 	int size;
    19. 	//初始化个数
    20. 	int capacity;
    21. }HP;
    22.  
    23. //初始化
    24. void HeapInit(HP* php);
    25. //建立二叉树
    26. void HeapInitArray(HP* php, int* a, int n);
    27. //销毁
    28. void HeapDestroy(HP* php);
    29.  
    30. //实现交换元素的函数
    31. void Swap(HPDataType* p1, HPDataType* p2);
    32. //实现向上调整建小堆
    33. void AdjustUp(HPDataType* a, int child);
    34. //实现向下调整建大堆
    35. void AdjustDown(HPDataType* a, int n, int parent);
    36.  
    37. //打印元素
    38. void HeapPrint(HP* php);
    39. //添加元素
    40. void HeapPush(HP* php, HPDataType x);
    41. //删除元素（这里可以实现排序 （从小到大） ）
    42. void HeapPop(HP* php);
    43. //返回第一个元素
    44. HPDataType HeapTop(HP* php);
    45. //判断不能没有元素
    46. bool HeapEmpty(HP* php);
    🌠Heap.c源文件
    1. //包含头文件
    2. #include"Heap.h"
    3.  
    4. //初始化
    5. void HeapInit(HP* php) 
    6. {
    7. 	//断言
    8. 	assert(php);
    9. 	//初始化
    10. 	php->a = NULL;
    11. 	php->size = 0;
    12. 	php->capacity = 0;
    13. }
    14.  
    15. //建立二叉树
    16. void HeapInitArray(HP* php, int* a, int n)
    17. {
    18. 	//断言
    19. 	assert(php);
    20. 	assert(a);
    21. 	//开辟空间
    22. 	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    23. 	//判断
    24. 	if (php->a == NULL)
    25. 	{
    26. 		perror("malloc fail");
    27. 		exit(-1);
    28. 	}
    29. 	//赋值
    30. 	php->size = n;
    31. 	php->capacity = n;
    32. 	//把a的元素拷贝的开辟的二叉树中
    33. 	memcpy(php->a, a, sizeof(HPDataType) * n);
    34. 	// 建堆
    35. 	for (int i = 1; i < n; i++)
    36. 	{
    37. 		//向上调整建小堆 实现取出最小的元素（后面会实现）
    38. 		AdjustUp(php->a, i);
    39. 	}
    40. }
    41.  
    42. //销毁
    43. void HeapDestroy(HP* php)
    44. {
    45. 	//断言
    46. 	assert(php);
    47. 	//释放内存
    48. 	free(php->a);
    49. 	php->a = NULL;
    50. 	php->size = php->capacity = 0;
    51. }
    52.  
    53. //实现交换元素的函数
    54. void Swap(HPDataType* p1, HPDataType* p2)
    55. {
    56. 	HPDataType tmp = *p1;
    57. 	*p1 = *p2;
    58. 	*p2 = tmp;
    59. }
    60.  
    61. //实现向上调整建小堆
    62. void AdjustUp(HPDataType* a, int child)
    63. {
    64. 	//父亲和孩子的关系
    65. 	int parent = (child - 1) / 2;
    66. 	while (child > 0)
    67. 	{
    68. 		//实现向上调整元素
    69. 		if (a[child] < a[parent])
    70. 		{
    71. 			Swap(&a[child], &a[parent]);
    72. 			child = parent;
    73. 			parent = (parent - 1) / 2;
    74. 		}
    75. 		else
    76. 		{
    77. 			break;
    78. 		}
    79. 	}
    80. }
    81.  
    82. //实现向下调整建大堆
    83. void AdjustDown(HPDataType* a, int n, int parent)
    84. {
    85. 	//孩子和父亲的关系 
    86. 	int child = parent * 2 + 1;
    87. 	while (child < n)
    88. 	{
    89. 		//找出小的那个孩子
    90. 		if (child + 1 < n && a[child + 1] < a[child])
    91. 		{
    92. 			++child;
    93. 		}
    94. 		//实现向下调整元素
    95. 		if (a[child] < a[parent])
    96. 		{
    97. 			Swap(&a[child], &a[parent]);
    98. 			// 继续往下调整
    99. 			parent = child;
    100. 			child = parent * 2 + 1;
    101. 		}
    102. 		else
    103. 		{
    104. 			break;
    105. 		}
    106. 	}
    107. }
    108.  
    109. //打印元素
    110. void HeapPrint(HP* php)
    111. {
    112. 	//断言
    113. 	assert(php);
    114.  
    115. 	for (size_t i = 0; i < php->size; i++)
    116. 	{
    117. 		printf("%d ", php->a[i]);
    118. 	}
    119. 	printf("\n");
    120. }
    121.  
    122. //添加元素
    123. void HeapPush(HP* php, HPDataType x)
    124. {
    125. 	//断言
    126. 	assert(php);
    127. 	//扩容（这里实现元素一个添加在堆中）
    128. 	//（需要主函数整个循环）
    129. 	if (php->size == php->capacity)
    130. 	{
    131. 		//实现扩容
    132. 		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    133. 		//开辟空间
    134. 		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newCapacity);
    135. 		//判断
    136. 		if (tmp == NULL)
    137. 		{
    138. 			perror("realloc fail");
    139. 			exit(-1);
    140. 		}
    141.  
    142. 		php->a = tmp;
    143. 		php->capacity = newCapacity;
    144. 	}
    145.  
    146. 	php->a[php->size] = x;
    147. 	php->size++;
    148. 	//添加元素后实现向上调整 建成小堆
    149. 	AdjustUp(php->a, php->size - 1);
    150. }
    151.  
    152. //删除元素（这里可以实现排序 （从小到大） ）
    153. void HeapPop(HP* php)
    154. {
    155. 	//断言
    156. 	assert(php);
    157. 	assert(php->size > 0);
    158. 	
    159. 	//第一个元素和最后一个元素交换
    160. 	Swap(&php->a[0], &php->a[php->size - 1]);
    161. 	--php->size;
    162. 	
    163. 	//向下调整后 就可以剥离出最后一个元素实现排序（小到大）
    164. 	AdjustDown(php->a, php->size, 0);
    165. }
    166.  
    167. //返回第一个元素
    168. HPDataType HeapTop(HP* php)
    169. {
    170. 	//断言
    171. 	assert(php);
    172. 	assert(php->size > 0);
    173. 	//返回第一个元素
    174. 	return php->a[0];
    175. }
    176.  
    177. //判断不能没有元素
    178. bool HeapEmpty(HP* php)
    179. {
    180. 	//断言
    181. 	assert(php);
    182. 	//
    183. 	return php->size == 0;
    184. }
    🌠Test.c源文件
    1. //包含头文件
    2. #include"Heap.h"
    3.  
    4. //int main()
    5. //{
    6. //	//int a[] = { 65,100,70,32,50,60 };
    7. //	int a[] = { 2,3,5,7,4,6,8,65,100,70,32,50,60 };
    8. //	HP hp;
    9. //	HeapInit(&hp);
    10. //	for (int i = 0; i < sizeof(a)/sizeof(int); i++)
    11. //	{
    12. //		HeapPush(&hp, a[i]);
    13. //	}
    14. //	HeapPrint(&hp);
    15. //
    16. //	int k = 5;
    17. //	while (!HeapEmpty(&hp) && k--)
    18. //	{
    19. //		printf("%d ", HeapTop(&hp));
    20. //		HeapPop(&hp);
    21. //	}
    22. //
    23. //	HeapDestroy(&hp);
    24. //
    25. //	return 0;
    26. //}
    27.  
    28. // 这种写法的缺点：
    29. // 1、先有一个堆的数据结构
    30. // 2、空间复杂度复杂度的消耗
    31.  
    32. //排序
    33. //void HeapSort(int* a, int n)
    34. //{
    35. //	//创建指针
    36. //	HP hp;
    37. //	//初始化
    38. //	HeapInit(&hp);
    39. //	for (int i = 0; i < n; i++)
    40. //	{
    41. //		//添加元素
    42. //		HeapPush(&hp, a[i]);
    43. //	}
    44. //	int i = 0;
    45. //	//不能没有元素
    46. //	while (!HeapEmpty(&hp))
    47. //	{
    48. //		//返回第一个元素
    49. //		printf("%d ", HeapTop(&hp));
    50. //		a[i++] = HeapTop(&hp);
    51. //		//删除元素（这里可以实现排序 （从小到大） ）
    52. //		HeapPop(&hp);
    53. //	}
    54. //	//销毁
    55. //	HeapDestroy(&hp);
    56. //}
    57.  
    58. //排序升序
    59. //void HeapSort(int* a, int n)
    60. //{
    61. //	// 向上调整建堆 （大堆）or  （小堆）
    62. //	// O(N*logN)
    63. //	/*for (int i = 1; i < n; i++)
    64. //	{
    65. //		AdjustUp(a, i);
    66. //	}*/
    67. //
    68. //	// 向下调整建堆
    69. //	// O(N)
    70. //	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    71. //	{
    72. //		AdjustDown(a, n, i);
    73. //	}
    74. //
    75. //	// O(N*logN)
    76. //	int end = n - 1;
    77. //	while (end > 0)
    78. //	{
    79. //		Swap(&a[0], &a[end]);
    80. //		AdjustDown(a, end, 0);
    81. //		--end;
    82. //	}
    83. //}
    84. //int main()
    85. //{
    86. //	//int a[] = { 65,100,70,32,50,60 };
    87. //	//int a[] = { 2,3,5,7,4,6,8,65,100,70,32,50,60 };
    88. //	//int a[] = { 70, 65, 100, 32, 50, 60 };
    89. //	int a[] = { 2,3,5,7,4,6,8 };
    90. //	HeapSort(a, sizeof(a) / sizeof(int));
    91. //
    92. //	return 0;
    93. //}
    💫拓展

             TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。  比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
    💦1. 用数据集合中前K个元素来建堆
           💧前k个最大的元素，则建小堆
           💧前k个最小的元素，则建大堆
    💦2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

    方法实现：

    1. //大量数据排序
    2. void PrintTopK(const char* filename, int k)
    3. {
    4. 	// 1. 建堆--用a中前k个元素建堆
    5. 	//打开文件
    6. 	FILE* fout = fopen(filename, "r");
    7. 	//判断是否打开文件
    8. 	if (fout == NULL)
    9. 	{
    10. 		perror("fopen fail");
    11. 		return;
    12. 	}
    13. 	
    14. 	//开辟空间
    15. 	int* minheap = (int*)malloc(sizeof(int) * k);
    16. 	//判断
    17. 	if (minheap == NULL)
    18. 	{
    19. 		perror("malloc fail");
    20. 		return;
    21. 	}
    22. 	
    23. 	//存入数据
    24. 	for (int i = 0; i < k; i++)
    25. 	{
    26. 		fscanf(fout, "%d", &minheap[i]);
    27. 	}
    28. 	// 前k个数建小堆
    29. 	for (int i = (k - 2) / 2; i >= 0; --i)
    30. 	{
    31. 		AdjustDown(minheap, k, i);
    32. 	}
    33.  
    34. 	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
    35. 	int x = 0;
    36. 	while (fscanf(fout, "%d", &x) != EOF)
    37. 	{
    38. 		if (x > minheap[0])
    39. 		{
    40. 			// 替换你进堆
    41. 			minheap[0] = x;
    42. 			AdjustDown(minheap, k, 0);
    43. 		}
    44. 	}
    45.  
    46. 	//打印数据
    47. 	for (int i = 0; i < k; i++)
    48. 	{
    49. 		printf("%d ", minheap[i]);
    50. 	}
    51. 	printf("\n");
    52.  
    53. 	//关闭文件
    54. 	fclose(fout);
    55. }
    56.  
    57. int main()
    58. {
    59. 	//创建数字
    60. 	CreateNDate();
    61. 	//实现寻找
    62. 	PrintTopK("data.txt", 5);
    63.  
    64. 	return 0;
    65. }

    🌝二叉树的链表存储结构

            在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

    💫初始化二叉树的链表存储结构

    这里就简单的续写咯

    1. //包含头文件
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. // 不是增删查改，学习二叉树结构
    8. typedef struct BinaryTreeNode
    9. {
    10. 	//左节点
    11. 	struct BinaryTreeNode* left;
    12. 	//右节点
    13. 	struct BinaryTreeNode* right;
    14. 	int val;
    15. }BTNode;
    16.  
    17.  
    18. //初始化
    19. BTNode* BuyNode(int x)
    20. {
    21. 	//开辟空间
    22. 	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    23. 	//判断
    24. 	if (node == NULL)
    25. 	{
    26. 		perror("malloc fail");
    27. 		exit(-1);
    28. 	}
    29. 	
    30. 	//初始化
    31. 	node->val = x;
    32. 	node->left = NULL;
    33. 	node->right = NULL;
    34.  
    35. 	//返回值
    36. 	return node;
    37. }
    💫二叉树的遍历
    按照规则，二叉树的遍历有： 前序 / 中序 / 后序的递归结构遍历 ：
    💦1. 前序遍历 (Preorder Traversal 亦称先序遍历 )—— 访问根结点的操作发生在遍历其左右子树之前。
    💦2. 中序遍历 (Inorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之中（间）。
    💦3. 后序遍历 (Postorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之后。 

    1. // 二叉树前序遍历
    2. void PrevOrder(BTNode* root) {
    3. 	
    4. 	if (root == NULL) 
    5. 	{
    6. 		printf("NULL ");
    7. 		return;
    8. 	}
    9.  
    10. 	printf("%d ", root->val);
    11. 	PrevOrder(root->left);
    12. 	PrevOrder(root->right);
    13. }
    14.  
    15. // 二叉树中序遍历
    16. void InOrder(BTNode* root)
    17. {
    18. 	if (root == NULL)
    19. 	{
    20. 		printf("NULL ");
    21. 		return;
    22. 	}
    23.  
    24. 	InOrder(root->left);
    25. 	printf("%d ", root->val);
    26. 	InOrder(root->right);
    27. }
    28.  
    29. // 二叉树后序遍历
    30. void PostOrder(BTNode* root)
    31. {
    32. 	if (root == NULL)
    33. 	{
    34. 		printf("NULL ");
    35. 		return;
    36. 	}
    37.  
    38. 	PostOrder(root->left);
    39. 	PostOrder(root->right);
    40. 	printf("%d ", root->val);
    41. }
    💫二叉树层序遍历

            层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

    不知道大家还记得队列不，这里可是需要用到哟。

    1. // 层序遍历
    2. void LevelOrder(BTNode* root)
    3. {
    4. 	Que q;
    5. 	//初始化
    6. 	QueueInit(&q);
    7.  
    8. 	if (root)
    9. 		//添加元素
    10. 		QueuePush(&q, root);
    11. 	//判断
    12. 	while (!QueueEmpty(&q))
    13. 	{
    14. 		//找头
    15. 		BTNode* front = QueueFront(&q);
    16. 		printf("%d ", front->val);
    17. 		if (front->left)
    18. 			//添加元素
    19. 			QueuePush(&q, front->left);
    20.  
    21. 		if (front->right)
    22. 			//添加元素
    23. 			QueuePush(&q, front->right);
    24. 		//删除元素
    25. 		QueuePop(&q);
    26. 	}
    27. 	printf("\n");
    28. 	//销毁
    29. 	QueueDestroy(&q);
    30. }
    💫二叉树的节点个数以及高度等 
    1. // 二叉树节点个数(总节点个数)
    2. int TreeSize(BTNode* root)
    3. {
    4. 	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
    5. }
    6.  
    7. // 叶子节点个数
    8. int TreeLeafSize(BTNode* root)
    9. {
    10. 	if (root == NULL)
    11. 		return 0;
    12.  
    13. 	if (root->left == NULL && root->right == NULL)
    14. 	{
    15. 		return 1;
    16. 	}
    17.  
    18. 	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
    19. }
    20.  
    21. // 第k层的节点个数
    22. int TreeKLevel(BTNode* root, int k)
    23. {
    24. 	assert(k > 0);
    25.  
    26. 	if (root == NULL)
    27. 		return 0;
    28.  
    29. 	if (k == 1)
    30. 	{
    31. 		return 1;
    32. 	}
    33.  
    34. 	return TreeKLevel(root->left, k - 1)
    35. 		+ TreeKLevel(root->right, k - 1);
    36. }
    37.  
    38. // 二叉树销毁
    39. void TreeDestroy(BTNode* root)
    40. {
    41. 	if (root == NULL)
    42. 	{
    43. 		return;
    44. 	}
    45.  
    46. 	TreeDestroy(root->left);
    47. 	TreeDestroy(root->right);
    48. 	free(root);
    49. 	//root = NULL;
    50. }
    51.  
    52. // 二叉树查找值为x的结点
    53. BTNode* TreeFind(BTNode* root, int x)
    54. {
    55. 	if (root == NULL)
    56. 		return NULL;
    57.  
    58. 	if (root->val == x)
    59. 		return root;
    60.  
    61. 	BTNode* ret = NULL;
    62. 	ret = TreeFind(root->left, x);
    63. 	if (ret)
    64. 		return ret;
    65.  
    66. 	ret = TreeFind(root->right, x);
    67. 	if (ret)
    68. 		return ret;
    69.  
    70. 	return NULL;
    71. }

    🌟结束语

           今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小说手给博主一键三连，有你们的支持是我最大的动力💞💞💞，回见。

  • 相关阅读:
    SpringBoot SSMP项目搭建保姆级教程
    IOS 16 RC升级 IOS 16 步骤
    微服务部署：灰度发布、蓝绿部署、金丝雀部署
    36、流程事务(transaction)
    helm kubernetes包管理工具
    面试必备！TCP协议经典十五连问！
    Linux系统资源监控nmon工具下载及使用介绍
    istio介绍(二)
    Android Studio adb WiFi插件的使用
    深入Linux：权限管理与常用命令详解
  • 原文地址：https://blog.csdn.net/AAlykk/article/details/133011824