• 一起学数据结构（9）——二叉树的链式存储及相关功能实现

         

    目录

    1. 二叉树的链式存储：

    2. 二叉树的前序遍历：

    3. 二叉树的中序遍历：

    4. 二叉树的后序遍历：

    5. 统计二叉树的结点总数

     

    6.统计二叉树的叶子结点数：

    7. 统计二叉树第层的结点数量：

    8. 二叉树的销毁：

    9.查找树中值为结点：

    10. 二叉树的层序遍历：

    11. 代码总览：

    11.1 头文件TRLIst.h

    11.2 函数实现文件TRList.c

    11.3 函数测试文件Test.c

      在数据结构的第七篇文章中提到，对于完全二叉树而言，可以采用顺序存储的方法来存储完全二叉树。但是对于非完全二叉树而言，（例如下图中给出的二叉树）存储方法需要采用链式存储。本文将围绕二叉树的链式存储展开，介绍链式存储方法以及此类二叉树相关功能的实现。

    1. 二叉树的链式存储：

            在前几篇文章介绍完全二叉树及堆的代码实现时，会涉及到此类数据结构的插入结点、删除结点等特点。但是，对于非完全二叉树，由于结构并不像完全二叉树一样有一定规律，因此，利用非完全二叉树存储数据的操作较为复杂。并且，在存储数据这一方面，之前的完全二叉树更为合适。所以，对于普通的非完全二叉树来说，插入、删除结点的操作是没有意义的。

           对于非完全二叉树的价值，主要是体现于后续更复杂的数据结构中，例如红黑树等。因此，文章后续实现的功能主要是利用递归来针对于非完全二叉树自身而言，例如求非完全二叉树的叶子结点数目，二叉树的深度等等。在二叉树的链式存储这一部分，将通过构建关于新建结点函数BuyTRNode来手动构建上图给出的非完全二叉树。

           对于非完全二叉树，在关于树的基础的文章中就提到，链式存储的方法可以归结为左孩子，右兄弟。所以，树的结点的结构如下：

    1. typedef int TRDataType;
    2. typedef struct TreeNode
    3. {
    4. 	TRDataType val;
    5. 	struct TreeNode* left;
    6. 	struct TreeNode* right;
    7. }TRNode;

       在确立了二叉树结点的结构之后，下一步构建函数BuyTRNode，代码如下：

    1. TRNode* BuyTRNode(int x)
    2. {
    3. 	TRNode* newnode = (TRNode*)malloc(sizeof(TRNode));
    4. 	if (newnode == NULL)
    5. 	{
    6. 		perror("malloc fail");
    7. 		exit(-1);
    8. 	}
    9. 	newnode->val = x;
    10. 	newnode->left = NULL;
    11. 	newnode->right = NULL;
    12. 	return newnode;
    13. }

    下一步，通过上面的两个函数，直接构建出上图中给出的非完全二叉树，即：

    1. int main()
    2. {
    3. 	TRNode* node1 = BuyTRNode(1);
    4. 	TRNode* node2 = BuyTRNode(2);
    5. 	TRNode* node3 = BuyTRNode(3);
    6. 	TRNode* node4 = BuyTRNode(4);
    7. 	TRNode* node5 = BuyTRNode(5);
    8. 	TRNode* node6 = BuyTRNode(6);
    9.  
    10. 	node1->left = node2;
    11. 	node1->right = node4;
    12. 	node2->left = node3;
    13. 	node4->left = node5;
    14. 	node4->right = node6;
    15.  
    16. 	return 0;
    17. }

    （注： 文章后续所有的运行结果均需要适配相应的测试代码，测试代码将在文章最后统一给出）

    2. 二叉树的前序遍历：

    对于二叉树的前序遍历，其顺序是按照：根结点，左结点，右结点进行访问的，例如对于上面给出的树：其结点访问顺序依次为（注：将空看作NULL结点）：1，2，3，NULL,NULL,NULL,4,5,NULL,NULL,6,NULL,NULL。

    利用图形来表示结点访问的顺序，即：

    其中3,5,8,13,17,19均代表访问到空结点，4,6,9,14,20代表访问到空结点后，返回上一个结点。在结点访问的过程中，每个结点都是按照：根结点、左结点、右结点的顺序。因此，对于这种重复性的问题，可以使用递归实现，具体代码如下：

    1. //前序遍历
    2. void PreOrder(TRNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return;
    7. 	}
    8.  
    9. 	//访问根结点：
    10. 	printf("%d ", root->val);
    11. 	//访问左结点：
    12. 	PreOrder(root->left);
    13. 	//访问右结点：
    14. 	PreOrder(root->right);
    15. }

    运行结果如下：

    3. 二叉树的中序遍历：

           二叉树的中序遍历顺序为：左结点、根结点、右结点，依旧针对于上面给出的二叉树，中序遍历对于结点的访问顺序为：NULL，3，NULL，2，NULL，1，NULL，5，NULL，4，NULL，6NULL。用图片表示结点的访问顺序，即：

    对应代码如下：

    1. //中序遍历
    2. void InOrder(TRNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return;
    7. 	}
    8.  
    9. 	//访问左结点：
    10. 	InOrder(root->left);
    11. 	//访问根结点：
    12. 	printf("%d ", root->val);
    13. 	//访问右结点：
    14. 	InOrder(root->right);
    15. }

    结果如下：

    4. 二叉树的后序遍历：

    二叉树的后序遍历顺序为：左结点，右结点，根结点。针对上方给出的二叉树，后序遍历访问结点的顺序依次为：NULL，NULL，3，NULL，2，NULL，NULL，5，NULL，NULL，6，4，1。

    用图形表示结点的访问顺序，即：

    对应代码如下：

    1. //后序遍历
    2. void PostOrder(TRNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return;
    7. 	}
    8.  
    9. 	//访问左结点：
    10. 	InOrder(root->left);
    11. 	//访问右结点：
    12. 	InOrder(root->right);
    13. 	//访问根结点：
    14. 	printf("%d ", root->val);
    15.  
    16. }

    结果如下： 

    5. 统计二叉树的结点总数

    对于统计二叉树的结点总数这一功能，可以拆分为以下步骤利用递归进行实现：

    1. 检测结点是否为空，如果为空，则表示结点为空，即不存在此结点，返回0。如果不为空，则表示存在本结点，结果加1并且向下检测本结点的左、右结点。

    2.在检测结点时，需要检测结点的左、右结点，检测方法参考1

    具体代码如下：

    1. //统计二叉树的结点树：
    2. int TreeSize(TRNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return 0;
    7. 	}
    8.  
    9. 	return TreeSize(root->left) + TreeSize(root->right) + 1;
    10. }

    测试结果如下：

     

    6.统计二叉树的叶子结点数：

    对于统计二叉树叶子结点数的功能实现，可以分成下面的部分：

    1. 检测本结点是否符合叶子结点的特点，即：root->left= NULL,并且root->right = NULL。如果符合，则返回值返回1。

    2.若本结点不符合1中的判定条件，则存在两种情况，一是本结点为空，二是本结点为分支结点。对于第一种情况，返回值返回0，对于第二种情况，则继续向下检测本结点的子结点，即root->left,root->right

    对应代码为：

    1. //统计二叉树的叶子结点数：
    2. int TreeLeafSize(TRNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return 0;
    7. 	}
    8. 	if (root->left == NULL && root->right == NULL)
    9. 	{
    10. 		return 1;
    11. 	}
    12.  
    13. 	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
    14. }

    运行结果如下：

    符合上图中的叶子结点数量。

    7. 统计二叉树第k层的结点数量：

    对于此功能的实现，同样可以分为下面的几步：

    1.额外创建一个变量k，用k来间接表示二叉树的层数，每经过依次递归，对k进行一次-1的操作。当k=0时，表示已经到达目标层数。此时，如果目标层存在结点，则返回值返回1.

    2.当k\neq 0时，表示还未到达目标层数，继续向下遍历该结点左、右两个子结点。

    3.在函数传参的时候，需要注意，不能传递k，需要传递k-1。具体代码如下：

    1. //统计二叉树第k层结点数
    2. int TNodeSize(TRNode* root, int k)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return 0;
    7. 	}
    8. 	if (k == 0)
    9. 	{
    10. 		return 1;
    11. 	}
    12.  
    13. 	return TNodeSize(root->left, k - 1) + TNodeSize(root->right, k - 1);
    14. }

    运行结果如下：


    结点数量符合上方给出的二叉树。 

    8. 二叉树的销毁：

    原理较为简单，只给出代码，不做过多解释：

    1. //二叉树的销毁
    2. void TNodeDestory(TRNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return;
    7. 	}
    8. 	TNodeDestory(root->left);
    9. 	TNodeDestory(root->right);
    10.  
    11. 	free(root);
    12. }

    9.查找树中值为X结点：

    对于查找树中值为X的结点这一功能，可以分成下面的步骤实现：

    1. 检测本结点是否为空，如果为空则返回NULL。

    2.若本结点不为空，则检测本结点中存储的数值是否=X，若符合条件，则返回该结点的地址。

    3.此时，结点即不为空，结点中存储的数值也\neq X，因此，继续遍历该结点的左、右两个子结点。

    对于函数返回值的处理，可以在函数中额外创建一个函数指针，为了方便表达，将这个指针命名为ret。

    如果函数的根结点中存储的数值就是X，则直接返回该结点指针。如果不等于，按照上面的思路，函数会继续遍历根结点的子结点。直接令ret接收函数的返回值，并且，在遍历的后方加上对于ret的判定。由于ret的返回值只存在两种情况，即NULL,root。所以，如果ret返回值不为ret，则不允许返回返回值。判定ret的返回值为root，则返回返回值。如果在函数遍历的过程中，所有的ret都不允许返回，则表示树种不存在存储数值为X的结点。直接返回NULL

    对应代码如下：

    1. //查找树中值为x的结点：
    2. TRNode* TRFind(TRNode* root,int x)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return NULL;
    7. 	}
    8. 	if (root->val = x)
    9. 	{
    10. 		return root;
    11. 	}
    12.  
    13. 	TRNode* ret = NULL;
    14. 	ret = TRFind(root->left, x);
    15. 	if (ret)
    16. 	{
    17. 			return ret;
    18. 	}
    19. 	ret = TRFind(root->right, x);
    20. 	if (ret)
    21. 	{
    22. 		return ret;
    23. 	}
    24.  
    25. 	return NULL;
    26. }

    运行结果如下：

    10. 二叉树的层序遍历：

    对于二叉树的层序遍历，由于需要每一层挨个访问结点，因此，不能再用前面递归的思想来实现此功能 。如果不采用递归，则必须对每个结点的数值进行一次存储。所以，文章这里利用队列来辅助实现二叉树的层序遍历

    （注：关于队列的相关知识及代码，可在前面的文章一起学数据结构（6）——栈和队列-CSDN博客获取，需要注意，在实现本功能时，需要将队列头文件中，typedef  int  QDataType改成typedef TreeNode  QDataType以便匹配后序的返回值）

    实现本功能的具体思路如下：

    1. 创建一个队列，为了方便表达，将这个队列命名为qs。

    2. 先往队列中利用插入函数QNodePush插入二叉树根结点的数值。

    3. 创建一个指针，命名为violent，利用这个指针来接受QueuePop函数(取队头元素函数)的返回值（返回值返回该结点的地址)。

    4.按照层序遍历的顺序(即：一层一层，从左到右访问结点)，向队列中插入数据，顺序为：插入左子结点，插入右子结点

    5.销毁队头指针，利用循环配合上述步骤来完成对整个二叉树的访问，判定条件为!QueueEmpty(探空函数）

    对应代码如下：
     

    1. //层序遍历
    2. void LevelOrder(Que* qs,TRNode* root)
    3. {
    4. 	if(root)
    5. 	QueuePush(qs, root);
    6.  
    7. 	while (!QueueEmpty(qs))
    8. 	{
    9. 		TRNode* violent = QueueFront(qs);
    10. 		printf("%d ", violent->val);
    11.  
    12. 		if (violent->left)
    13. 			QueuePush(qs,violent->left);
    14. 		if (violent->right)
    15. 			QueuePush(qs,violent->right);
    16.  
    17. 		QueuePop(qs);
    18. 	}
    19.  
    20.  
    21. }

    运行结果如下：

     

    11. 代码总览：

    11.1 头文件TRLIst.h

    1. #include
    2. #include
    3. #include
    4.  
    5. typedef int TRDataType;
    6. typedef struct TreeNode
    7. {
    8. 	TRDataType val;
    9. 	struct TreeNode* left;
    10. 	struct TreeNode* right;
    11. }TRNode;
    12.  
    13. #include"queue.h"
    14.  
    15. //结点插入函数
    16. TRNode* BuyTRNode(int x);
    17.  
    18. //前序遍历
    19. void PreOrder(TRNode* root);
    20.  
    21. //中序遍历
    22. void InOrder(TRNode* root);
    23.  
    24. //后序遍历
    25. void PostOrder(TRNode* root);
    26.  
    27. //统计二叉树的结点树：
    28. int TreeSize(TRNode* root);
    29.  
    30. //统计二叉树的叶子结点数：
    31. int TreeLeafSize(TRNode* root);
    32.  
    33. //统计二叉树第k层结点数
    34. int TNodeSize(TRNode* root, int k);
    35.  
    36. //二叉树的销毁
    37. void TNodeDestory(TRNode* root);
    38.  
    39. //查找树中值为x的结点：
    40. TRNode* TRFind(TRNode* root, int x);
    41.  
    42. //层序遍历
    43. void LevelOrder(Que* qs,TRNode* root);

    11.2 函数实现文件TRList.c

    1. #include"TRList.h"
    2.  
    3. //结点插入函数
    4. TRNode* BuyTRNode(int x)
    5. {
    6. 	TRNode* newnode = (TRNode*)malloc(sizeof(TRNode));
    7. 	if (newnode == NULL)
    8. 	{
    9. 		perror("malloc fail");
    10. 		exit(-1);
    11. 	}
    12. 	newnode->val = x;
    13. 	newnode->left = NULL;
    14. 	newnode->right = NULL;
    15. 	return newnode;
    16. }
    17.  
    18. //前序遍历
    19. void PreOrder(TRNode* root)
    20. {
    21. 	if (root == NULL)
    22. 	{
    23. 		return;
    24. 	}
    25.  
    26. 	//访问根结点：
    27. 	printf("%d ", root->val);
    28. 	//访问左结点：
    29. 	PreOrder(root->left);
    30. 	//访问右结点：
    31. 	PreOrder(root->right);
    32. }
    33.  
    34. //中序遍历
    35. void InOrder(TRNode* root)
    36. {
    37. 	if (root == NULL)
    38. 	{
    39. 		return;
    40. 	}
    41.  
    42. 	//访问左结点：
    43. 	InOrder(root->left);
    44. 	//访问根结点：
    45. 	printf("%d ", root->val);
    46. 	//访问右结点：
    47. 	InOrder(root->right);
    48. }
    49.  
    50. //后序遍历
    51. void PostOrder(TRNode* root)
    52. {
    53. 	if (root == NULL)
    54. 	{
    55. 		return;
    56. 	}
    57.  
    58. 	//访问左结点：
    59. 	InOrder(root->left);
    60. 	//访问右结点：
    61. 	InOrder(root->right);
    62. 	//访问根结点：
    63. 	printf("%d ", root->val);
    64. }
    65.  
    66. //统计二叉树的结点树：
    67. int TreeSize(TRNode* root)
    68. {
    69. 	if (root == NULL)
    70. 	{
    71. 		return 0;
    72. 	}
    73.  
    74. 	return TreeSize(root->left) + TreeSize(root->right) + 1;
    75. }
    76.  
    77. //统计二叉树的叶子结点数：
    78. int TreeLeafSize(TRNode* root)
    79. {
    80. 	if (root == NULL)
    81. 	{
    82. 		return 0;
    83. 	}
    84. 	if (root->left == NULL && root->right == NULL)
    85. 	{
    86. 		return 1;
    87. 	}
    88.  
    89. 	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
    90. }
    91.  
    92. //统计二叉树第k层结点数
    93. int TNodeSize(TRNode* root, int k)
    94. {
    95. 	if (root == NULL)
    96. 	{
    97. 		return 0;
    98. 	}
    99. 	if (k == 0)
    100. 	{
    101. 		return 1;
    102. 	}
    103.  
    104. 	return TNodeSize(root->left, k - 1) + TNodeSize(root->right, k - 1);
    105. }
    106.  
    107. //二叉树的销毁
    108. void TNodeDestory(TRNode* root)
    109. {
    110. 	if (root == NULL)
    111. 	{
    112. 		return;
    113. 	}
    114. 	TNodeDestory(root->left);
    115. 	TNodeDestory(root->right);
    116.  
    117. 	free(root);
    118. }
    119.  
    120. //查找树中值为x的结点：
    121. TRNode* TRFind(TRNode* root,int x)
    122. {
    123. 	if (root == NULL)
    124. 	{
    125. 		return NULL;
    126. 	}
    127. 	if (root->val = x)
    128. 	{
    129. 		return root;
    130. 	}
    131.  
    132. 	TRNode* ret = NULL;
    133. 	ret = TRFind(root->left, x);
    134. 	if (ret)
    135. 	{
    136. 			return ret;
    137. 	}
    138. 	ret = TRFind(root->right, x);
    139. 	if (ret)
    140. 	{
    141. 		return ret;
    142. 	}
    143.  
    144. 	return NULL;
    145. }
    146.  
    147. //层序遍历
    148. void LevelOrder(Que* qs,TRNode* root)
    149. {
    150. 	if(root)
    151. 	QueuePush(qs, root);
    152.  
    153. 	while (!QueueEmpty(qs))
    154. 	{
    155. 		TRNode* violent = QueueFront(qs);
    156. 		printf("%d ", violent->val);
    157.  
    158. 		if (violent->left)
    159. 			QueuePush(qs,violent->left);
    160. 		if (violent->right)
    161. 			QueuePush(qs,violent->right);
    162.  
    163. 		QueuePop(qs);
    164. 	}
    165.  
    166.  
    167. }

    11.3 函数测试文件Test.c

    1. #include"TRList.h"
    2.  
    3.  
    4. void TestOrder(TRNode* root)
    5. {
    6. 	printf("前序遍历：");
    7. 	PreOrder(root);
    8. 	printf("\n");
    9. 	printf("中序遍历：");
    10. 	InOrder(root);
    11. 	printf("\n");
    12. 	printf("后序遍历：");
    13. 	PostOrder(root);
    14. 	printf("\n");
    15. }
    16.  
    17. void TestNode(TRNode* root)
    18. {
    19. 	printf("二叉树的结点总数为：");
    20. 	int sum = TreeSize(root);
    21. 	printf("%d ", sum);
    22. 	printf("\n");
    23. 	int sum1 = TreeLeafSize(root);
    24. 	printf("二叉树叶子结点总数为：");
    25. 	printf("%d ", sum1);
    26. 	printf("\n");
    27. 	
    28. 	int k = 0;
    29. 	printf("请输入k的值：");
    30. 	scanf("%d", &k);
    31. 	int sum2 = TNodeSize(root, k-1);
    32. 	printf("\n");
    33. 	printf("二叉树第K层结点数量为：");
    34. 	printf("%d ", sum2);
    35. 	printf("\n");
    36. }
    37.  
    38. void TestTRDes(TRNode* root)
    39. {
    40. 	printf("请输入想要查找的值：");
    41. 	int x = 0;
    42. 	scanf("%d", &x);
    43. 	TRNode* ret = NULL;
    44. 	ret = TRFind(root, x);
    45. 	printf("\n");
    46. }
    47.  
    48.  
    49.  
    50. void TestLOrder(TRNode* root)
    51. {
    52. 	Que qs;
    53. 	QueueInit(&qs);
    54. 	LevelOrder(&qs, root);
    55. 	QueueDestory(&qs);
    56. }
    57.  
    58. int main()
    59. {
    60. 	TRNode* node1 = BuyTRNode(1);
    61. 	TRNode* node2 = BuyTRNode(2);
    62. 	TRNode* node3 = BuyTRNode(3);
    63. 	TRNode* node4 = BuyTRNode(4);
    64. 	TRNode* node5 = BuyTRNode(5);
    65. 	TRNode* node6 = BuyTRNode(6);
    66.  
    67. 	node1->left = node2;
    68. 	node1->right = node4;
    69. 	node2->left = node3;
    70. 	node4->left = node5;
    71. 	node4->right = node6;
    72.  
    73.  
    74. 	TestOrder(node1);
    75. 	TestNode(node1);
    76. 	TestTRDes(node1);
    77. 	TestLOrder(node1);
    78. 	return 0;
    79. }

  • 相关阅读:
    含文档+PPT+源码等]精品基于Uniapp实现的移动端的医生寻访平台的设计与实现[包运行成功]
    体系结构28_多处理机（2）
    TVS管和ESD管的技术指标和选型指南-嘉立创推荐
    如果再来一次，你还会选择互联网么？
    [Mono Depth/3DOD]单目3D检测基础
    【理论】车辆双轴振动模型（二）
    深入理解ThreadLocal源码
    JS的装箱和拆箱
    国产API管理平台，我为何选择 Eolink
    水果叠叠乐
  • 原文地址：https://blog.csdn.net/2301_76836325/article/details/133892886