• 【数据结构】二叉树链式结构的实现

    前言

    上篇博客我们说了有关二叉树顺序结构——堆，堆是完全二叉树，但我们对于普通的二叉树（不一定为完全二叉树），我们该用什么结构实现那，本篇就来详细说一下，二叉树另一个实现的结构，链式结构

    💓 个人主页：小张同学zkf

    ⏩ 文章专栏：数据结构

          若有问题 评论区见📝

    🎉欢迎大家点赞👍收藏⭐文章

     

     

    目录

     1.二叉树的创建与遍历

    1.1 前序，中序，后序遍历

    1.2层序遍历 

    1.3二叉树的创建

    2.二叉树的节点个数

    3.二叉树的叶子结点个数

    4.二叉树的深度

    5.寻找x节点

    6.判断是否为完全二叉树

    7.销毁二叉树

    8.以下是二叉树的实现

     

     1.二叉树的创建与遍历

    1.1 前序，中序，后序遍历

    看这个题之前，我们先来说一下三个遍历

    学习二叉树结构，最简单的方式就是遍历。所谓 二叉树遍历 (Traversal) 是按照某种特定的规则，依次对二叉 树中的结点进行相应的操作，并且每个结点只操作一次 。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础

     

    按照规则，二叉树的遍历有： 前序 / 中序 / 后序的递归结构遍历 ：
    1. 前序遍历 (Preorder Traversal 亦称先序遍历 )—— 访问根结点的操作发生在遍历其左右子树之前。
    2. 中序遍历 (Inorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之中（间）。
    3. 后序遍历 (Postorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之后。
    由于被访问的结点必是某子树的根， 所以 N(Node ）、 L(Left subtree ）和 R(Right subtree ）又可解释为 根、根的左子树和根的右子树 。 NLR 、 LNR 和 LRN 分别又称为先根遍历、中根遍历和后根遍历。
    前序遍历递归图解 ：

     

    对上图，遍历结果如下
    前序遍历结果： 1 2 3 4 5 6
    中序遍历结果： 3 2 1 5 4 6
    后序遍历结果： 3 2 5 6 4 1

    那了解了三个遍历，那对应的代码如何实现那？

    我们可以用递归来解决

    假如，传入函数的节点是空那就直接返回，若不为空，打印当前数值，把对应的左孩子与右孩子分别传进去，子节点与其父亲节点处理问题思路相同，符合把大事化小原则，是递归思想，那前中后序代码，其实就是打印与递归顺序不同，前序就是先打印再递归左孩子，最后递归右孩子，而中序就是先递归左孩子，再打印，再递归右孩子，后序就是先递归左孩子，再递归右孩子，最后打印

    代码如下

    1. void BinaryTreePrevOrder(BTNode* root)//前序遍历
    2. {
    3. 	if (root == NULL)
    4. 	{
    5. 		return 0;
    6. 	}
    7. 	printf("%c ", root->_data);
    8. 	BinaryTreePrevOrder(root->_left);
    9. 	BinaryTreePrevOrder(root->_right);
    10. }
    11. void BinaryTreeInOrder(BTNode* root)//中序遍历
    12. {
    13. 	if (root == NULL)
    14. 	{
    15. 		return 0;
    16. 	}
    17. 	BinaryTreePrevOrder(root->_left);
    18. 	printf("%c ", root->_data);
    19. 	BinaryTreePrevOrder(root->_right);
    20. }
    21. void BinaryTreePostOrder(BTNode* root)//后序遍历
    22. {
    23. 	if (root == NULL)
    24. 	{
    25. 		return 0;
    26. 	}
    27. 	BinaryTreePrevOrder(root->_left);
    28. 	BinaryTreePrevOrder(root->_right);
    29. 	printf("%c ", root->_data);
    30. }

    1.2层序遍历 

     还有一种遍历是层序遍历

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

    那么层序遍历的代码如何实现

    这里我们需要用到我们之前学到的队列，我们可以将一个根节点打入队列，再让他出队列，出队列的节点打印，出队列同时，将他的左右子树再打入队列，前提左右孩子节点不为空，继续上述的操作，直到队列为空时循环停止。

    代码如下

    1. void BinaryTreeLevelOrder(BTNode* root)//层序遍历
    2. {
    3. 	Queue as;
    4. 	QueueInit(&as);
    5. 	QueuePush(&as, root);
    6. 	while (!QueueEmpty(&as))
    7. 	{
    8. 		BTNode* aq = QueueFront(&as);
    9. 		QueuePop(&as);
    10. 		printf("%c", aq->_data);
    11. 		if (aq->_left)
    12. 		{
    13. 			QueuePush(&as, aq->_left);
    14. 		}
    15. 		if (aq->_right)
    16. 		{
    17. 			QueuePush(&as, aq->_right);
    18. 		}
    19. 	}
    20. 	QueueDestroy(&as);
    21. }

    1.3二叉树的创建

     

    我们再回归到这个题，我们可以用先序遍历创建二叉树，我们现将数组首地址以及下标地址传进函数中，如果数组里的值为‘#’此处创建空节点，若不是，开辟一个二叉树的结构体空间，左右孩子子树也是这么创建的，子问题思路相同符合先序遍历的递归，左右孩子创建都用递归，别忘了下标访问一次数组，要自增，最后返回这个根节点

    代码如下

    BTNode* BinaryTreeCreate(BTDataType* a, int* pi)//通过前序遍历，创建二叉树
    {
        if (a[*pi] == '#')
        {
            (*pi)++;
            return NULL;
        }
        BTNode* qa = (BTNode*)malloc(sizeof(BTNode));
        qa->_data = a[(*pi)++];
        qa->_left = BinaryTreeCreate(a, pi);
        qa->_right = BinaryTreeCreate(a, pi);
        return qa;
    }

    最后再中序遍历打印就行了，代码在上面打过了

    2.二叉树的节点个数

    二叉树遍历与构建都清楚了，那我们如何用代码统计二叉树的节点个数，我们想想如果二叉树的节点为空，那么个数就返回0，若不为空，就是自身节点算一个，左孩子节点个数加右孩子节点个数加1（自身）,那么对于子问题也是如此求个数，可以用递归，为了节省效率，可以用三目操作符。

    1. int BinaryTreeSize(BTNode* root)//节点个数
    2. {
    3. 	return root == NULL ? 0 : BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
    4. }

     如果递归想不出来的话，我们可以举个例子，方便我们记忆

    假如一个学校让统计在校人数，校长吩咐给院长，院长吩咐给辅导员，辅导员吩咐给班长，班长统计人数返回给辅导员，辅导员把俩班人数加起来再加自身返回给院长，院长也是如此最后返回给校长，这其实就是二叉树的节点通过递归的统计方法，我们可以类比想一下

    3.二叉树的叶子结点个数

    叶子节点他的左孩子与右孩子都为空节点，我们计算二叉树叶子结点的个数，跟计算节点的个数类似，只不过此刻不需要加自身，只需要计算每个节点的左孩子叶子节点个数加右孩子叶子节点的个数就行了，如果我们找到一个叶子结点，返回1，若空节点返回0

    代码如下

    1. int BinaryTreeLeafSize(BTNode* root)//叶子结点个数
    2. {
    3. 	if (root == NULL)
    4. 	{
    5. 		return 0;
    6. 	}
    7. 	if (root->_left == NULL && root->_right == NULL)
    8. 	{
    9. 		return 1;
    10. 	}
    11. 	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
    12. }

    那这个代码我们是否可以衍生出返回第K行节点个数，不返回最后一行叶子结点个数，返回任意一行节点个数 

    假如我返回第三行的节点个数，那在我们遍历过程中，我们如何确定节点是否是第三行那，我们有图可以过一行K减一，只要向下递归一行K减一，到目标行第三行K就是1，也就是说，若K等于1，到达目标行

    代码如下

    1.  
    2. int BinaryTreeLevelKSize(BTNode* root, int k)//二叉树第k个节点
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return 0;
    7. 	}
    8. 	if (k == 1)
    9. 	{
    10. 		return 1;
    11. 	}
    12. 	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
    13. }

    4.二叉树的深度

    二叉树的深度，就是通过比较左右子树深度高的那个加一，不断递归，找到最高的深度，代码如下

     

     

    这里我们要注意一下，如图第一个代码，三目操作符你会发现大的那位会多调用一次，若递归越深，效率会急速下降，所以我们可以将他们的值用临时变量来判断

    5.寻找x节点

    这个首先通过先序遍历遍历每个节点，找到的话返回这个节点，若没找到，返回NULL，扎到的话用临时变量接收，不能直接返回，以为在递归遍历中，你返回返回的是递归过程中上一个函数，并不能完全返回出来，要想在递归中返回出来，就要用变量不断接收。

    代码如下

    1. BTNode* BinaryTreeFind(BTNode* root, BTDataType x)//二叉树找值为x的节点
    2. {
    3. 	if (root == NULL)
    4. 	{
    5. 		return NULL;
    6. 	}
    7. 	if (root->_data == x)
    8. 	{
    9. 		return root;
    10. 	}
    11. 	BTNode* as = BinaryTreeFind(root->_left, x);
    12. 	if (as)
    13. 		return as;
    14. 	BTNode* ak = BinaryTreeFind(root->_right, x);
    15. 	if (ak)
    16. 		return ak;
    17. 	return NULL;
    18. }

    6.判断是否为完全二叉树

    怎么判断这个二叉树为完全二叉树那

    我们沿用层序遍历的思路，层序遍历是将每个节点传入队列里，然后通过出队列顺序达到目的，那我们画图来看一下

     

     由图可见，我们层序遍历过程中，若遇见空节点，我们要判断此刻队列里是否还有非空节点，若有则代表不连续，不是完全二叉树，若没有则是完全二叉树

    代码如下

    1. int BinaryTreeComplete(BTNode* root)//判断是否是完全二叉树
    2. {
    3.     Queue as;
    4.     QueueInit(&as);
    5.     QueuePush(&as, root);
    6.     while (!QueueEmpty(&as))
    7.     {
    8.         BTNode* aq = QueueFront(&as);
    9.         QueuePop(&as);
    10.         if (aq == NULL)
    11.         {
    12.             break;
    13.         }
    14.             QueuePush(&as, aq->_left);
    15.             QueuePush(&as, aq->_right);
    16.     }
    17.     while (!QueueEmpty(&as))
    18.     {
    19.         BTNode* ad = QueueFront(&as);
    20.         if (ad)
    21.         {
    22.             QueueDestroy(&as);
    23.             return 0;
    24.         }
    25.     }
    26.     QueueDestroy(&as);
    27.     return 1;
    28. }
    29.

    7.销毁二叉树

    销毁二叉树不能从根开始消除，如果把根消除，怎么访问孩子节点，这是大忌！！！

    我们得采用后序遍历来进行销毁，从叶子结点开始消除

    代码如下

    1. void BinaryTreeDestory(BTNode** root)//销毁二叉树
    2. {
    3. 	if (*root == NULL)
    4. 	{
    5. 		return 0;
    6. 	}
    7. 	BinaryTreeDestory((*root)->_left);
    8. 	BinaryTreeDestory((*root)->_right);
    9. 	free(root);
    10. }

    8.以下是二叉树的实现

    .h 

    1. #pragma once
    2. typedef char BTDataType;
    3.  
    4. typedef struct BinaryTreeNode
    5. {
    6. 	BTDataType _data;
    7. 	struct BinaryTreeNode* _left;
    8. 	struct BinaryTreeNode* _right;
    9. }BTNode;
    10. #include "队列.h"
    11. // 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
    12. BTNode* BinaryTreeCreate(BTDataType* a, int* pi);
    13. // 二叉树销毁
    14. void BinaryTreeDestory(BTNode** root);
    15. // 二叉树节点个数
    16. int BinaryTreeSize(BTNode* root);
    17. // 二叉树叶子节点个数
    18. int BinaryTreeLeafSize(BTNode* root);
    19. //二叉树的高度
    20. int BinaryTreeHeight(BTNode* root);
    21. // 二叉树第k层节点个数
    22. int BinaryTreeLevelKSize(BTNode* root, int k);
    23. // 二叉树查找值为x的节点
    24. BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
    25. // 二叉树前序遍历 
    26. void BinaryTreePrevOrder(BTNode* root);
    27. // 二叉树中序遍历
    28. void BinaryTreeInOrder(BTNode* root);
    29. // 二叉树后序遍历
    30. void BinaryTreePostOrder(BTNode* root);
    31. // 层序遍历
    32. void BinaryTreeLevelOrder(BTNode* root);
    33. // 判断二叉树是否是完全二叉树
    34. int BinaryTreeComplete(BTNode* root);

    .c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "二叉树.h"
    3.  
    4. //BTNode* BTNodecreat(int i)
    5. //{
    6. //	BTNode* as = (BTNode*)malloc(sizeof(BTNode));
    7. //	as->_data = i;
    8. //	as->_left = NULL;
    9. //	as->_right = NULL;
    10. //}
    11.  
    12. BTNode* BinaryTreeCreate(BTDataType* a, int* pi)//通过前序遍历，创建二叉树
    13. {
    14. 	/*BTNode* s1 = BTNodecreat(1);
    15. 	BTNode* s2 = BTNodecreat(2);
    16. 	BTNode* s3 = BTNodecreat(3);
    17. 	BTNode* s4 = BTNodecreat(4);
    18. 	BTNode* s5 = BTNodecreat(5);
    19. 	BTNode* s6 = BTNodecreat(6);
    20. 	s1->_left = s2;
    21. 	s1->_right = s3;
    22. 	s2->_left = s4;
    23. 	s2->_right = s5;
    24. 	s3->_left = s6;*/
    25. 	if (a[*pi] == '#')
    26. 	{
    27. 		(*pi)++;
    28. 		return NULL;
    29. 	}
    30. 	BTNode* qa = (BTNode*)malloc(sizeof(BTNode));
    31. 	qa->_data = a[(*pi)++];
    32. 	qa->_left = BinaryTreeCreate(a, pi);
    33. 	qa->_right = BinaryTreeCreate(a, pi);
    34. 	return qa;
    35. }
    36. void BinaryTreePrevOrder(BTNode* root)//前序遍历
    37. {
    38. 	if (root == NULL)
    39. 	{
    40. 		return 0;
    41. 	}
    42. 	printf("%c ", root->_data);
    43. 	BinaryTreePrevOrder(root->_left);
    44. 	BinaryTreePrevOrder(root->_right);
    45. }
    46. void BinaryTreeInOrder(BTNode* root)//中序遍历
    47. {
    48. 	if (root == NULL)
    49. 	{
    50. 		return 0;
    51. 	}
    52. 	BinaryTreePrevOrder(root->_left);
    53. 	printf("%c ", root->_data);
    54. 	BinaryTreePrevOrder(root->_right);
    55. }
    56. void BinaryTreePostOrder(BTNode* root)//后序遍历
    57. {
    58. 	if (root == NULL)
    59. 	{
    60. 		return 0;
    61. 	}
    62. 	BinaryTreePrevOrder(root->_left);
    63. 	BinaryTreePrevOrder(root->_right);
    64. 	printf("%c ", root->_data);
    65. }
    66. int BinaryTreeSize(BTNode* root)//节点个数
    67. {
    68. 	return root == NULL ? 0 : BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
    69. }
    70. int BinaryTreeLeafSize(BTNode* root)//叶子结点个数
    71. {
    72. 	if (root == NULL)
    73. 	{
    74. 		return 0;
    75. 	}
    76. 	if (root->_left == NULL && root->_right == NULL)
    77. 	{
    78. 		return 1;
    79. 	}
    80. 	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
    81. }
    82. int BinaryTreeLevelKSize(BTNode* root, int k)//二叉树第k个节点
    83. {
    84. 	if (root == NULL)
    85. 	{
    86. 		return 0;
    87. 	}
    88. 	if (k == 1)
    89. 	{
    90. 		return 1;
    91. 	}
    92. 	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
    93. }
    94. BTNode* BinaryTreeFind(BTNode* root, BTDataType x)//二叉树找值为x的节点
    95. {
    96. 	if (root == NULL)
    97. 	{
    98. 		return NULL;
    99. 	}
    100. 	if (root->_data == x)
    101. 	{
    102. 		return root;
    103. 	}
    104. 	BTNode* as = BinaryTreeFind(root->_left, x);
    105. 	if (as)
    106. 		return as;
    107. 	BTNode* ak = BinaryTreeFind(root->_right, x);
    108. 	if (ak)
    109. 		return ak;
    110. 	return NULL;
    111. }
    112. void BinaryTreeDestory(BTNode** root)//销毁二叉树
    113. {
    114. 	if (*root == NULL)
    115. 	{
    116. 		return 0;
    117. 	}
    118. 	BinaryTreeDestory((*root)->_left);
    119. 	BinaryTreeDestory((*root)->_right);
    120. 	free(root);
    121. }
    122. int BinaryTreeHeight(BTNode* root)//二叉树的深度
    123. {
    124. 	if (root == NULL)
    125. 		return 0;
    126. 	return fmax(BinaryTreeHeight(root->_left), BinaryTreeHeight(root->_right))+1;
    127. }
    128. void BinaryTreeLevelOrder(BTNode* root)//层序遍历
    129. {
    130. 	Queue as;
    131. 	QueueInit(&as);
    132. 	QueuePush(&as, root);
    133. 	while (!QueueEmpty(&as))
    134. 	{
    135. 		BTNode* aq = QueueFront(&as);
    136. 		QueuePop(&as);
    137. 		printf("%c", aq->_data);
    138. 		if (aq->_left)
    139. 		{
    140. 			QueuePush(&as, aq->_left);
    141. 		}
    142. 		if (aq->_right)
    143. 		{
    144. 			QueuePush(&as, aq->_right);
    145. 		}
    146. 	}
    147. 	QueueDestroy(&as);
    148. }
    149. int BinaryTreeComplete(BTNode* root)//判断是否是完全二叉树
    150. {
    151. 	Queue as;
    152. 	QueueInit(&as);
    153. 	QueuePush(&as, root);
    154. 	while (!QueueEmpty(&as))
    155. 	{
    156. 		BTNode* aq = QueueFront(&as);
    157. 		QueuePop(&as);
    158. 		if (aq == NULL)
    159. 		{
    160. 			break;
    161. 		}
    162. 			QueuePush(&as, aq->_left);
    163. 			QueuePush(&as, aq->_right);
    164. 	}
    165. 	while (!QueueEmpty(&as))
    166. 	{
    167. 		BTNode* ad = QueueFront(&as);
    168. 		if (ad)
    169. 		{
    170. 			QueueDestroy(&as);
    171. 			return 0;
    172. 		}
    173. 	}
    174. 	QueueDestroy(&as);
    175. 	return 1;
    176. }

    test.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "二叉树.h"
    3. int main()
    4. {
    5. 	char a[] ="ABD##E#H##CF##G##";
    6. 	int i = 0;
    7. 	BTNode* root = BinaryTreeCreate(a, &i);
    8. 	BinaryTreePrevOrder(root);
    9. 	printf("\n");
    10. 	BinaryTreeInOrder(root);
    11. 	printf("\n");
    12. 	printf("TreeSize:%d\n", BinaryTreeSize(root));
    13. 	printf("TreeLeafSize:%d\n", BinaryTreeLeafSize(root));
    14. 	printf("TreeHeight:%d\n", BinaryTreeHeight(root));
    15. 	printf("TreeLevelKSize:%d\n", BinaryTreeLevelKSize(root, 3));
    16. 	printf("TreeLevelKSize:%d\n", BinaryTreeLevelKSize(root, 4));
    17.  
    18. 	BinaryTreeLevelOrder(root);
    19. 	printf("\n");
    20.  
    21. 	BinaryTreeDestory(root);
    22. 	root = NULL;
    23.  
    24. 	return 0;
    25. }

    结束语 

    二叉树的链式结构实现到此结束，这也是一个普通二叉树的实现，这一块需要好好理解递归思想，递归还掌握不好的可以去看看小编之前的函数递归，递归熟练的相信二叉树对你来说没有什么问题

    OK本篇博客结束，感谢观看！！！

     

  • 相关阅读:
    Unity 自制转表插件,高效便捷,无反射代码
    自己动手从零写桌面操作系统GrapeOS系列教程——14.屏幕显示原理与文本模式
    LVS-DR模式
    C#调用Windows API实现自定义打印纸张大小
    Java并发编程的艺术笔记-Java中的线程池
    【附源码】Python计算机毕业设计实验室耗材管理系统
    【API接口功能】以图搜款，最快1秒助您找到想要的商品！
    基于STC12C5A60S2系列1T 8051单片机的模数芯片ADC0832实现模数转换应用
    50个渗透(黑客)常用名词及解释
    十三、SpringBoot错误处理底层组件和异常处理流程分析
  • 原文地址：https://blog.csdn.net/m0_74091744/article/details/139391453