• 模拟实现链式二叉树及其结构学习——【数据结构】

    W...Y的主页 😊

    代码仓库分享 💕

    之前我们实现了用顺序表完成二叉树(也就是堆)，顺序二叉树的实际作用就是解决堆排序以及Topk问题。

    今天我们要学习的内容是链式二叉树，并且实现链式二叉树，这篇博客与递归息息相关！

    目录

    链式存储

    二叉树链式结构的实现

    链式二叉树的快速创建

    二叉树的遍历

    前序、中序以及后序遍历

    前序遍历的实现

    中序遍历的实现

    后序遍历实现

    节点个数以及高度

    总结点个数

    叶子节点个数

    第k层节点个数

    整个代码模板以及验证

    链式存储

    什么是链式存储，就是用链来指示元素的逻辑关系。链式结构又分为二叉链和三叉链，而我们今天学习的是二叉链表，又称链式二叉树。

    我们一般用链表来表示一棵二叉树，通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。

    1. typedef int BTDataType;
    2. // 二叉链
    3. struct BinaryTreeNode
    4. {
    5.     struct BinTreeNode* _pLeft; // 指向当前节点左孩子
    6.     struct BinTreeNode* _pRight; // 指向当前节点右孩子
    7.     BTDataType _data; // 当前节点值域
    8. }

    对于链式二叉树，我们与其他前面的链表、顺序表、堆……数据结构有所不同，我们针对这一块并不是增删查改，为什么呢?

    因为链式二叉树的存储方式，就是把每一个节点封装在结构体中然后进行链接， 而我们进行增删查改没有必要在这么复杂的结构中实现，当我有每个节点的左右指针时，我可以随心所欲，在哪里都可以进行插入删除。如果非得使用增删查改，我们就可以使用简单一些的数据结构进行。

    所以我们学习链式二叉树是为了给我们后面的高级数据结构AVL、红黑树打基础的。所以我们也要认真学！！！

    二叉树链式结构的实现

    链式二叉树的快速创建

    我们为了快速实现链式二叉树，从中感受到链式二叉树的结构，我们快速手动生成一个链式二叉树。

    1. #include
    2. #include
    3. #include
    4. typedef struct BinaryTreeNode
    5. {
    6. 	struct BinaryTreeNode* left;
    7. 	struct BinaryTreeNode* right;
    8. 	int val;
    9. }BTNode;
    10. BTNode* BuyNode(int x)
    11. {
    12. 	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    13. 	if (node == NULL)
    14. 	{
    15. 		perror("malloc fail");
    16. 		exit(-1);
    17. 	}
    18. 	node->val = x;
    19. 	node->left = NULL;
    20. 	node->right = NULL;
    21. 	
    22. 	return node;
    23. }
    24. int main(void)
    25. {
    26. 	BTNode* node1 = BuyNode(1);
    27. 	BTNode* node2 = BuyNode(2);
    28. 	BTNode* node3 = BuyNode(3);
    29. 	BTNode* node4 = BuyNode(4);
    30. 	BTNode* node5 = BuyNode(5);
    31. 	BTNode* node6 = BuyNode(6);
    32.  
    33. 	node1->left = node2;
    34. 	node1->right = node4;
    35. 	node2->left = node3;
    36. 	node4->left = node5;
    37. 	node4->right = node6;
    38.     return 0;
    39. }

    我们创建了链式二叉树的基本结构，左指针右指针以及存储的值，然后开辟空间将里面的所有内容初始化。在main函数中手动插入了1、2、3、4、5、6封装在结构体中，然后依照下图进行链接快速得到一个链式二叉树。

     下面依照创建完成的链式二叉树继续学习。

    二叉树的遍历

    前序、中序以及后序遍历

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

    按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：
    1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树前。
    2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
    3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

    由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。 

    前序遍历的实现

    针对前序遍历，我们记住先访问左树，再访问根，最后再访问右树。我们可以先手动遍历一遍，将一颗大树分解成三部分（左树、根、右树），再将左树看作树继续分成左树右树与根，右数也一样，将其一直进行分解，直到左右树为空为止即可停止。

    1. // 二叉树前序遍历
    2. void PreOrder(BTNode* root)
    3. {
    4.     if (root == NULL)
    5. 	{
    6. 		return;
    7. 	}
    8. 	printf("%d ", root->val);
    9. 	PrevOrder(root->left);
    10. 	PrevOrder(root->right);
    11. }

     在前序遍历中，我们使用递归进行。如果root为NULL证明树为空，直接返回即可。当进入下面代码时，前序遵循的是根、左树、右树。所以我们先将根打印出来，然后遍历左树。当进入左树递归时，root->left进入左树，那根的左子节点就变成了左树的根，打印出来继续递归，依次类推。而右树也是一样的，将左树遍历完后，我们将递归右数，先将左树递归的所有函数销毁，进入root->right中进行递归，根的右子节点成为右树的根，打印出进行递归，一直遵循根、左树、右树进行。

    递归图解如下：

     虽然代码非常简洁，但是理解起来不太容易，我们不能只记住代码如何写，应该理解其中的原理才行。

    中序遍历的实现

    只要我们理解了前序遍历，那么中序后序都是非常简单的存在。只需记住：左树、根、右树，然后写出递归即可

    1. void InOrder(BTNode* root)
    2. {
    3. 	if (root == NULL)
    4. 	{
    5. 		return;
    6. 	}
    7. 	InOrder(root->left);
    8. 	printf("%d ", root->val);
    9. 	InOrder(root->right);
    10. }

     有没有发现这串代码与前序遍历非常相似，只是将两行代码交换位置就可以实现。我们先将左树的内容递归完然后打印，再打印根的，最后再打印右树的即可。可以参考前置遍历进行推理。

    这里如果实在理解不了的可以认为调用InOrder(root->left)是遍历打印左树，printf是打印根，而调用递归InOrder(root->right)是为了遍历打印右树。

    后序遍历实现

    我相信大家已经知道函数怎么写了，那我就直接给模板：

    1. void PostOrder(BTNode* root)
    2. {
    3. 	if (root == NULL)
    4. 	{
    5. 		return;
    6. 	}
    7. 	PostOrder(root->left);
    8. 	PostOrder(root->right);
    9. 	printf("%d ", root->val);
    10. }

     下面我们更进一步的学习链式二叉树的结构，上强度！！！

    节点个数以及高度

    总结点个数

    我们需要建立一个函数，求出整个二叉树所有的节点个数。

    有人一定会想直接全部遍历一遍然后创建一个全局变量用来统计个数就可以了。没错这个方法是可行的，我们刚才说的二叉树的遍历，然后在这里用一遍不就拿下来了。

    1. int size = 0;
    2. int TreeSize(BTNode* root)
    3. {
    4. 	if (root == NULL)
    5. 		return 0;
    6. 	else
    7. 		++size;
    8. 	TreeSize(root->left);
    9. 	TreeSize(root->right);
    10. 	return size;
    11. }

    我们直接遍历整棵树，先遍历左树、再遍历右数，每遍历一个节点size++即可。

    但是这个函数有一个极大的缺点，当我们使用函数时，我们可以在任意一个位置去调用，全局变量是存储在静态区的，不会随着函数的结束而销毁，当我们调用过一次后， 再一次去调用此函数，如果没有及时将size归零，结果将会累加起来成为错误的结果。

    我们应该优化一下程序：

    1. int TreeSize(BTNode* root)
    2. {
    3. 	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
    4. }

    直接使用递归，将左右子树包含在返回值中，我们在后面加上1，如果递归成功将+1，然后返回最后递归之和。

    我们可以做个比喻：在一个大学中校长想要统计全校的人数，校长不可能亲自挨家挨户访问查人，它会通知每个院的院长，然后院长通知每个系的系主任，由系主任通知导员，最后由导员通知每个班的班长来统计人数。一级一级的下放任务。而这个递归也是如此，统计总节点个数就是一级一级下方给各个节点计数。 

    叶子节点个数

    需要求出链式二叉树的叶子节点个数，叶节点或终端节点：度为0的节点称为叶节点；

    大致原理都是一样的，只是条件不同。我们需要叶子节点就必须是度为0的节点，所以一个节点的root->right == NULL && root->left == NULL 这是必要条件，然后我们就应该去遍历二叉树的左子树与右子树去寻找满足条件的节点。最后求出左右子树的叶子节点之和即可。

    代码实现：

    1. int TreeLeafSize(BTNode* root)
    2. {
    3. 	if (root == NULL)
    4. 		return 0;
    5. 	if (root->right == NULL && root->left == NULL)
    6. 		return 1;
    7. 	return TreeLeafSize(root->right) + TreeLeafSize(root->left);
    8. }

    第k层节点个数

    当我们需要某一层的节点个数，我们也需要创建一个函数来进行，那我们应该怎么弄呢？

    还是一级一级去派遣，假设我们需要第三层的节点个数，当我们刚进入在第一层时，我们距离目标层数还有两层之差，当我们遍历到第二层时，我们距离目标还有一层，当我们进入目标层后我们就要进行遍历节点， 统计出左右子树k层节点之和返回即可。

    1. int TreeKLevel(BTNode* root, int k)
    2. {
    3. 	assert(k > 0);
    4. 	if (root == NULL)
    5. 	{
    6. 		return 0;	
    7. 	}
    8. 	if (k == 1)
    9. 	{
    10. 		return 1;
    11. 	}
    12. 	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);
    13. }

    需要注意的是我们先得使用assert进行断言，防止树为空。

    整个代码模板以及验证

    下面是增章全部代码以及测试用例：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include
    4. #include
    5. #include
    6. typedef struct BinaryTreeNode
    7. {
    8. 	struct BinaryTreeNode* left;
    9. 	struct BinaryTreeNode* right;
    10. 	int val;
    11. }BTNode;
    12.  
    13. BTNode* BuyNode(int x)
    14. {
    15. 	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    16. 	if (node == NULL)
    17. 	{
    18. 		perror("malloc fail");
    19. 		exit(-1);
    20. 	}
    21. 	node->val = x;
    22. 	node->left = NULL;
    23. 	node->right = NULL;
    24. 	
    25. 	return node;
    26. }
    27.  
    28. void PrevOrder(BTNode* root)
    29. {
    30. 	if (root == NULL)
    31. 	{
    32. 		return;
    33. 	}
    34. 	printf("%d ", root->val);
    35. 	PrevOrder(root->left);
    36. 	PrevOrder(root->right);
    37. }
    38.  
    39. void InOrder(BTNode* root)
    40. {
    41. 	if (root == NULL)
    42. 	{
    43. 		return;
    44. 	}
    45. 	InOrder(root->left);
    46. 	printf("%d ", root->val);
    47. 	InOrder(root->right);
    48. }
    49. void PostOrder(BTNode* root)
    50. {
    51. 	if (root == NULL)
    52. 	{
    53. 		return;
    54. 	}
    55. 	PostOrder(root->left);
    56. 	PostOrder(root->right);
    57. 	printf("%d ", root->val);
    58. }
    59. //总节点个数
    60. //int TreeSize(BTNode* root)
    61. //{
    62. //	static int size = 0;
    63. //	if (root == NULL)
    64. //		return 0;
    65. //	else
    66. //		++size;
    67. //	TreeSize(root->left);
    68. //	TreeSize(root->right);
    69. //	return size;
    70. //}
    71. //int size = 0;
    72. //int TreeSize(BTNode* root)
    73. //{
    74. //	if (root == NULL)
    75. //		return 0;
    76. //	else
    77. //		++size;
    78. //	TreeSize(root->left);
    79. //	TreeSize(root->right);
    80. //	return size;
    81. //}
    82. int TreeSize(BTNode* root)
    83. {
    84. 	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
    85. }
    86. //叶子节点个数
    87. int TreeLeafSize(BTNode* root)
    88. {
    89. 	if (root == NULL)
    90. 		return 0;
    91. 	if (root->right == NULL && root->left == NULL)
    92. 		return 1;
    93. 	return TreeLeafSize(root->right) + TreeLeafSize(root->left);
    94. }
    95. //第k层节点个数
    96. int TreeKLevel(BTNode* root, int k)
    97. {
    98. 	assert(k > 0);
    99. 	if (root == NULL)
    100. 	{
    101. 		return 0;	
    102. 	}
    103. 	if (k == 1)
    104. 	{
    105. 		return 1;
    106. 	}
    107. 	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);
    108. }
    109.  
    110. int main(void)
    111. {
    112. 	BTNode* node1 = BuyNode(1);
    113. 	BTNode* node2 = BuyNode(2);
    114. 	BTNode* node3 = BuyNode(3);
    115. 	BTNode* node4 = BuyNode(4);
    116. 	BTNode* node5 = BuyNode(5);
    117. 	BTNode* node6 = BuyNode(6);
    118.  
    119. 	node1->left = node2;
    120. 	node1->right = node4;
    121. 	node2->left = node3;
    122. 	node4->left = node5;
    123. 	node4->right = node6;
    124. 	PrevOrder(node1);
    125. 	printf("\n");
    126. 	InOrder(node1);
    127. 	printf("\n");
    128. 	PostOrder(node1);
    129. 	printf("\n%d", TreeSize(node1));
    130.  
    131. 	printf("\n%d", TreeSize(node1));
    132. 	printf("\n%d", TreeLeafSize(node1));
    133. 	printf("\n%d", TreeKLevel(node1, 2));
    134. 	return 0;
    135. }

    代码运行结果如下：

    运行结果分别为前置遍历、中序遍历、后序遍历、总节点个数(两次)、叶子节点个数、第二层节点个数

     参考下图均正确！！！

    以上就是本次博客的全部内容，希望可以帮助到大家！！！支持博主的一键三连一下，谢谢大家❤️

  • 相关阅读:
    【全志T113-S3_100ask】7-编译Tina系统初体验
    IO模型简介
    Go基本数据类型
    Doris最全使用手册
    如何判断一款GameFi游戏是否有发展空间？
    自定义注解结合SpringAop实现权限，参数校验，日志等等功能
    Idea远程debug操作步骤（连接服务器）
    【花雕动手做】有趣好玩的音乐可视化系列小项目（17）--光导纤维灯
    盲埋孔PCB叠孔设计的利与弊
    动态规划一
  • 原文地址：https://blog.csdn.net/m0_74755811/article/details/132920802