devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

[数据结构初阶]二叉树

作者：繁依Fanyi0 | 2024-04-10 05:31:14

赞

踩

[数据结构初阶]二叉树

我们在前两篇博客中主要介绍了堆及其应用，针对的对象堆是完全二叉树，存储方式采用顺序结构存储的方式。

那么好的，这篇博客我们浅谈二叉树的链式存储，针对的对象是二叉树，并不局限于完全二叉树了！

我们先来回顾以下二叉树的定义：

一棵二叉树是结点的一个有限集合，该集合:
1. 或者为空（就是说空树也是二叉树）。
2. 不是空树：由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 

说简单点呢，二叉树是一颗特殊的树，这颗树的度最大为2，就像是对这颗树的节点进行了计划生育，最多只能生两个节点宝宝。 

从图可以看出：

1. 二叉树不存在度大于2的结点。
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。

3.二叉树的子树也都是二叉树，既然是二叉树就可以为空树。

从概念中可以看出，二叉树定义是递归式的：二叉树被拆成根节点、左子树和右子树，子树又被拆成根节点、左子树和右子树……直到拆成空树停止。因此后序基本操作中基本都是按照该概念实现的。

讲二叉树的链式存储，鼠鼠我需要构建一颗链式二叉树，鼠鼠先用硬编码的方式构建一颗二叉树，真正的链式二叉树构建是用递归构建的，鼠鼠后面讲：

  1. typedef char BTDataType;
  2.  
  3. typedef struct BTNode
  4. {
  5. 	BTDataType data;
  6. 	struct BTNode* leftchild;
  7. 	struct BTNode* rightchild;
  8. }BTNode;
  9.  
  10. //动态申请二叉树节点
  11. BTNode* CreateBinaryTreeNode(BTDataType data)
  12. {
  13. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  14. 	if (tmp == NULL)
  15. 	{
  16. 		perror("malloc fail");
  17. 		exit(-1);
  18. 	}
  19. 	tmp->data = data;
  20. 	tmp->leftchild = NULL;
  21. 	tmp->rightchild = NULL;
  22. 	return tmp;
  23. }
  24.  
  25. int main()
  26. {
  27. 	BTNode* node1 = CreateBinaryTreeNode('A');
  28. 	BTNode* node2 = CreateBinaryTreeNode('B');
  29. 	BTNode* node3 = CreateBinaryTreeNode('C');
  30. 	BTNode* node4 = CreateBinaryTreeNode('D');
  31. 	BTNode* node5 = CreateBinaryTreeNode('E');
  32. 	BTNode* node6 = CreateBinaryTreeNode('F');
  33. 	BTNode* node7 = CreateBinaryTreeNode('G');
  34. 	BTNode* node8 = CreateBinaryTreeNode('H');
  35. 	BTNode* node9 = CreateBinaryTreeNode('I');
  36. 	node1->leftchild = node2;
  37. 	node1->rightchild = node6;
  38. 	node2->leftchild = node3;
  39. 	node3->leftchild = node4;
  40. 	node4->rightchild = node5;
  41. 	node6->leftchild = node7;
  42. 	node7->leftchild = node8;
  43. 	node8->rightchild = node9;
  44. 	return 0;
  45. }

对于链式二叉树来说是由一个个节点构成的，我们定义节点如BTNode所示，很简单就不解释了。用也是很简单的逻辑我们写出了动态申请二叉树节点这个函数，在main函数上我们就可以调用该函数构建任意我们想要的链式二叉树，如代码所示我们构建的链式二叉树想象图为：

1.二叉树的遍历

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

1.1.前序遍历、中序遍历和后序遍历

二叉树的递归结构遍历有：前序/中序/后序的递归结构遍历：

1. 前序遍历(Preorder Traversal 亦称先序遍历)：访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)：访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)：访问根结点的操作发生在遍历其左右子树之后。

就拿上面我们构建的二叉树来说：

前序遍历依次访问的节点是：ABCD#E####FGH#I#### 。

前序遍历划分层次为：

中序遍历依次访问的节点是：#D#E#C#B#A#H#I#G#F#。

中序遍历划分层次为：

后序遍历依次访问的节点是：###ED#C#B#H##I#G#FA。

后序遍历划分层次为：

其实并不是很复杂，拿前序遍历来说，我们知道二叉树是递归式定义的，每棵二叉树都可以拆成根节点、左子树和右子树……这样子一直拆，知道拆到空树为止。只要保证每棵二叉树访问顺序都是根节点——左子树——右子树。

注：这里的#表示访问到了空节点。

那么我们用递归实现的代码如下，我们通过前序/中序/后序遍历访问节点用于打印节点数据，这样我们可以很好的证实我们访问的顺序是符合上面分析的：

  1. // 二叉树前序遍历
  2. void BinaryTreePrevOrder(BTNode* root)
  3. {
  4. 	if (root == NULL)
  5. 	{
  6. 		printf("# ");
  7. 		return;
  8. 	}
  9. 	//根节点
  10. 	printf("%c ", root->data);
  11. 	//左子树
  12. 	BinaryTreePrevOrder(root->leftchild);
  13. 	//右子树
  14. 	BinaryTreePrevOrder(root->rightchild);
  15. }
  16.  
  17. //二叉树中序遍历
  18. void BinaryTreeInOrder(BTNode* root)
  19. {
  20. 	if (root == NULL)
  21. 	{
  22. 		printf("# ");
  23. 		return;
  24. 	}
  25. 	//左子树
  26. 	BinaryTreeInOrder(root->leftchild);
  27. 	//根节点
  28. 	printf("%c ", root->data);
  29. 	//右子树
  30. 	BinaryTreeInOrder(root->rightchild);
  31. }
  32.  
  33. // 二叉树后序遍历
  34. void BinaryTreePostOrder(BTNode* root)
  35. {
  36. 	if (root == NULL)
  37. 	{
  38. 		printf("# ");
  39. 		return;
  40. 	}
  41. 	//左子树
  42. 	BinaryTreePostOrder(root->leftchild);
  43. 	//右子树
  44. 	BinaryTreePostOrder(root->rightchild);
  45. 	//根节点
  46. 	printf("%c ", root->data);
  47. }

 完整代码如下，将下面三个文件放到一个工程下面运行即可出结果：

1.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. //动态申请二叉树节点
  15. BTNode* CreateBinaryTreeNode(BTDataType data);
  16.  
  17. // 二叉树前序遍历
  18. void BinaryTreePrevOrder(BTNode* root);
  19.  
  20. //二叉树中序遍历
  21. void BinaryTreeInOrder(BTNode* root);
  22.  
  23. // 二叉树后序遍历
  24. void BinaryTreePostOrder(BTNode* root);

2.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4.  
  5. //动态申请二叉树节点
  6. BTNode* CreateBinaryTreeNode(BTDataType data)
  7. {
  8. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  9. 	if (tmp == NULL)
  10. 	{
  11. 		perror("malloc fail");
  12. 		exit(-1);
  13. 	}
  14. 	tmp->data = data;
  15. 	tmp->leftchild = NULL;
  16. 	tmp->rightchild = NULL;
  17. 	return tmp;
  18. }
  19.  
  20. // 二叉树前序遍历
  21. void BinaryTreePrevOrder(BTNode* root)
  22. {
  23. 	if (root == NULL)
  24. 	{
  25. 		printf("# ");
  26. 		return;
  27. 	}
  28. 	//根节点
  29. 	printf("%c ", root->data);
  30. 	//左子树
  31. 	BinaryTreePrevOrder(root->leftchild);
  32. 	//右子树
  33. 	BinaryTreePrevOrder(root->rightchild);
  34. }
  35.  
  36. //二叉树中序遍历
  37. void BinaryTreeInOrder(BTNode* root)
  38. {
  39. 	if (root == NULL)
  40. 	{
  41. 		printf("# ");
  42. 		return;
  43. 	}
  44. 	//左子树
  45. 	BinaryTreeInOrder(root->leftchild);
  46. 	//根节点
  47. 	printf("%c ", root->data);
  48. 	//右子树
  49. 	BinaryTreeInOrder(root->rightchild);
  50. }
  51.  
  52. // 二叉树后序遍历
  53. void BinaryTreePostOrder(BTNode* root)
  54. {
  55. 	if (root == NULL)
  56. 	{
  57. 		printf("# ");
  58. 		return;
  59. 	}
  60. 	//左子树
  61. 	BinaryTreePostOrder(root->leftchild);
  62. 	//右子树
  63. 	BinaryTreePostOrder(root->rightchild);
  64. 	//根节点
  65. 	printf("%c ", root->data);
  66. }

3.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	BTNode* node1 = CreateBinaryTreeNode('A');
  6. 	BTNode* node2 = CreateBinaryTreeNode('B');
  7. 	BTNode* node3 = CreateBinaryTreeNode('C');
  8. 	BTNode* node4 = CreateBinaryTreeNode('D');
  9. 	BTNode* node5 = CreateBinaryTreeNode('E');
  10. 	BTNode* node6 = CreateBinaryTreeNode('F');
  11. 	BTNode* node7 = CreateBinaryTreeNode('G');
  12. 	BTNode* node8 = CreateBinaryTreeNode('H');
  13. 	BTNode* node9 = CreateBinaryTreeNode('I');
  14. 	node1->leftchild = node2;
  15. 	node1->rightchild = node6;
  16. 	node2->leftchild = node3;
  17. 	node3->leftchild = node4;
  18. 	node4->rightchild = node5;
  19. 	node6->leftchild = node7;
  20. 	node7->leftchild = node8;
  21. 	node8->rightchild = node9;
  22.  
  23. 	// 二叉树前序遍历
  24. 	 BinaryTreePrevOrder(node1);
  25. 	 printf("\n");
  26.  
  27. 	//二叉树中序遍历
  28. 	 BinaryTreeInOrder(node1);
  29. 	 printf("\n");
  30.  
  31. 	// 二叉树后序遍历
  32. 	 BinaryTreePostOrder(node1);
  33. 	 printf("\n");
  34.  
  35. 	return 0;
  36. }

运行结果：

我们看跟分析的结果一模一样。不过一般访问到空树的时候我们是不对其进行操作的，因为空树没有存储数据，没有操作的必要，这里遇到空树的时候打印'#'是为了更好验证分析！ 

 鼠鼠在这里顺便提一嘴，前序遍历是一种深度优先遍历（dfs）。

1.2.层序遍历

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

拿这棵二叉树来说，层序遍历访问节点的顺序是ABFCGDHEI。

问题来了，我们如何实现层序遍历？ 

其实不难，这里我们不用递归实现，借用之前实现的队列即可。主要思想是 先将节点A的地址入队列，这样节点A地址就在对头了，再读取对头数据（即节点A地址）并将节点A地址出队列，通过读取的对头数据（即节点A地址）将A节点的左右子节点地址依次入队列（若为空指针就不入队列）。这样节点B的地址就在对头了，再读取对头数据（即节点B地址）并将节点B地址出队列，通过读取的对头数据（即节点B地址）将B节点的左右子节点地址依次入队列（若为空指针就不入队列）。这样节点F地址就在对头了，再……循环直到队列为空就停止这样就实现了层序遍历。

说通俗点就是A带B和F，B带C，F带G，C带D，G带H，D带E，H带I，当I出队列时队列就空了，那么就遍历完了！

层序遍历的代码如下，按照层序遍历访问节点打印出数据：

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

我们用到了队列，只要将先前实现好的队列头文件和源文件复制粘贴到当前工程下，再包含队列头文件即可使用队列。当然因为我们在队列中存储的数据是节点的指针，所以头文件中的QDatatype要有所更改。完整代码如下，将下面五个文件放到一个工程下面就可以运行出结果：

1.queue.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<assert.h>
  4. #include<stdlib.h>
  5. #include<stdbool.h>
  6.  
  7. #include"BinaryTree.h"
  8.  
  9. typedef BTNode* QDatatype;
  10.  
  11. typedef struct QNode
  12. {
  13. 	QDatatype _data;
  14. 	struct  QNode* _next;
  15. }QNode;
  16.  
  17. typedef struct Queue
  18. {
  19. 	int k;
  20. 	QNode* head;
  21. 	QNode* tail;
  22. }Queue;
  23.  
  24. //初始化队列
  25. void QueueInit(Queue* q);
  26.  
  27. //队尾入数据
  28. void QueuePush(Queue* q, QDatatype data);
  29.  
  30. //对头出数据
  31. void QueuePop(Queue* q);
  32.  
  33. //获取队列对头元素
  34. QDatatype QueueFront(Queue* q);
  35.  
  36. //获取队列队尾元素
  37. QDatatype QueueBack(Queue* q);
  38.  
  39. //获取队列中有效元素个数
  40. int QueueSize(Queue* q);
  41.  
  42. //检测队列是否为空，如果为空返回非零结果，非空返回0
  43. bool QueueEmpty(Queue* q);
  44.  
  45. //销毁队列
  46. void QueueDestroy(Queue* q);

2.queue.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include"queue.h"
  3.  
  4. void QueueInit(Queue* q)
  5. {
  6. 	assert(q);
  7. 	q->head = q->tail = NULL;
  8. 	q->k = 0;
  9. }
  10.  
  11. void QueuePush(Queue* q, QDatatype data)
  12. {
  13. 	assert(q);
  14. 	QNode* tmp = (QNode*)malloc(sizeof(QNode));
  15. 	if (tmp == NULL)
  16. 	{
  17. 		perror("malloc fail");
  18. 		return;
  19. 	}
  20. 	tmp->_data = data;
  21. 	tmp->_next = NULL;
  22. 	if (q->tail == NULL)
  23. 	{
  24. 		q->head = q->tail = tmp;
  25. 	}
  26. 	else
  27. 	{
  28. 		q->tail->_next = tmp;
  29. 		q->tail = tmp;
  30. 	}
  31. 	q->k++;
  32. }
  33.  
  34. void QueuePop(Queue* q)
  35. {
  36. 	assert(q);
  37. 	assert(q->k > 0);
  38. 	QNode* next = q->head->_next;
  39. 	free(q->head);
  40. 	q->head = next;
  41. 	if (q->head == NULL)
  42. 	{
  43. 		q->tail = NULL;
  44. 	}
  45. 	q->k--;
  46. }
  47.  
  48. QDatatype QueueFront(Queue* q)
  49. {
  50. 	assert(q);
  51. 	assert(q->k > 0);
  52. 	return q->head->_data;
  53. }
  54.  
  55. QDatatype QueueBack(Queue* q)
  56. {
  57. 	assert(q);
  58. 	assert(q->k > 0);
  59. 	return q->tail->_data;
  60. }
  61.  
  62. int QueueSize(Queue* q)
  63. {
  64. 	assert(q);
  65. 	return q->k;
  66. }
  67.  
  68. bool QueueEmpty(Queue* q)
  69. {
  70. 	assert(q);
  71. 	return q->tail == NULL;
  72. }
  73.  
  74. void QueueDestroy(Queue* q)
  75. {
  76. 	assert(q);
  77. 	QNode* tmp = q->head;
  78. 	while (tmp)
  79. 	{
  80. 		QNode* next = tmp->_next;
  81. 		free(tmp);
  82. 		tmp = next;
  83. 	}
  84. 	q->k = 0;
  85. 	q->head = q->tail = NULL;
  86. }

3.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. //动态申请二叉树节点
  15. BTNode* CreateBinaryTreeNode(BTDataType data);
  16.  
  17. // 层序遍历
  18. void BinaryTreeLevelOrder(BTNode* root);

4.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4. #include"queue.h"
  5.  
  6. //动态申请二叉树节点
  7. BTNode* CreateBinaryTreeNode(BTDataType data)
  8. {
  9. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  10. 	if (tmp == NULL)
  11. 	{
  12. 		perror("malloc fail");
  13. 		exit(-1);
  14. 	}
  15. 	tmp->data = data;
  16. 	tmp->leftchild = NULL;
  17. 	tmp->rightchild = NULL;
  18. 	return tmp;
  19. }
  20.  
  21. // 层序遍历
  22. void BinaryTreeLevelOrder(BTNode* root)
  23. {
  24. 	Queue q;
  25. 	QueueInit(&q);
  26. 	QueuePush(&q, root);
  27. 	while (!QueueEmpty(&q))
  28. 	{
  29. 		BTNode* front = QueueFront(&q);
  30. 		QueuePop(&q);
  31. 		printf("%c ", front->data);
  32. 		if (front->leftchild)
  33. 		{
  34. 			QueuePush(&q, front->leftchild);
  35. 		}
  36. 		if (front->rightchild)
  37. 		{
  38. 			QueuePush(&q, front->rightchild);
  39. 		}
  40. 	}
  41. 	QueueDestroy(&q);
  42. }

5.test.c

  1. #include"queue.h"
  2. #include"BinaryTree.h"
  3.  
  4. int main()
  5. {
  6. 	BTNode* node1 = CreateBinaryTreeNode('A');
  7. 	BTNode* node2 = CreateBinaryTreeNode('B');
  8. 	BTNode* node3 = CreateBinaryTreeNode('C');
  9. 	BTNode* node4 = CreateBinaryTreeNode('D');
  10. 	BTNode* node5 = CreateBinaryTreeNode('E');
  11. 	BTNode* node6 = CreateBinaryTreeNode('F');
  12. 	BTNode* node7 = CreateBinaryTreeNode('G');
  13. 	BTNode* node8 = CreateBinaryTreeNode('H');
  14. 	BTNode* node9 = CreateBinaryTreeNode('I');
  15. 	node1->leftchild = node2;
  16. 	node1->rightchild = node6;
  17. 	node2->leftchild = node3;
  18. 	node3->leftchild = node4;
  19. 	node4->rightchild = node5;
  20. 	node6->leftchild = node7;
  21. 	node7->leftchild = node8;
  22. 	node8->rightchild = node9;
  23.     
  24.     //层序遍历
  25. 	BinaryTreeLevelOrder(node1);
  26. 	return 0;
  27. }

运行结果如下：

 结果确实如我们分析所料，一层一层遍历访问节点并打印出节点存储的数据。

我们看上面运行结果来说是将所有节点数据全部打印到一行上了，那我们如何将所有节点数据分层打印出来呢？就是说第一行打印A；第二行打印B、F ；第三行打印C、G；第四行打印D、H；第五行打印E、I。

这个本质也是层序遍历，自是要控制好打印换行的时机罢了，我们看看代码：

  1. //分层的层序遍历
  2. void _BinaryTreeLevelOrder(BTNode* root)
  3. {
  4. 	Queue q;
  5. 	QueueInit(&q);
  6. 	QueuePush(&q, root);
  7. 	int size = 1;
  8. 	while (!QueueEmpty(&q))
  9. 	{
  10. 		while (size--)
  11. 		{
  12. 			BTNode* front = QueueFront(&q);
  13. 			printf("%c ", front->data);
  14. 			QueuePop(&q);
  15. 			if (front->leftchild)
  16. 			{
  17. 				QueuePush(&q, front->leftchild);
  18. 			}
  19. 			if (front->rightchild)
  20. 			{
  21. 				QueuePush(&q, front->rightchild);
  22. 			}
  23. 		}
  24. 		printf("\n");
  25. 		size = QueueSize(&q);
  26. 	}
  27. 	QueueDestroy(&q);
  28. }

这是其中一种办法，用一个size变量来记录每层的数据个数，那么每当size减到0就打印换行即可。 

 完整代码如下，将下面5个文件放到同一个工程下面运行即可得出结果：

1.queue.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<assert.h>
  4. #include<stdlib.h>
  5. #include<stdbool.h>
  6.  
  7. #include"BinaryTree.h"
  8.  
  9. typedef BTNode* QDatatype;
  10.  
  11. typedef struct QNode
  12. {
  13. 	QDatatype _data;
  14. 	struct  QNode* _next;
  15. }QNode;
  16.  
  17. typedef struct Queue
  18. {
  19. 	int k;
  20. 	QNode* head;
  21. 	QNode* tail;
  22. }Queue;
  23.  
  24. //初始化队列
  25. void QueueInit(Queue* q);
  26.  
  27. //队尾入数据
  28. void QueuePush(Queue* q, QDatatype data);
  29.  
  30. //对头出数据
  31. void QueuePop(Queue* q);
  32.  
  33. //获取队列对头元素
  34. QDatatype QueueFront(Queue* q);
  35.  
  36. //获取队列队尾元素
  37. QDatatype QueueBack(Queue* q);
  38.  
  39. //获取队列中有效元素个数
  40. int QueueSize(Queue* q);
  41.  
  42. //检测队列是否为空，如果为空返回非零结果，非空返回0
  43. bool QueueEmpty(Queue* q);
  44.  
  45. //销毁队列
  46. void QueueDestroy(Queue* q);

2.queue.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include"queue.h"
  3.  
  4. void QueueInit(Queue* q)
  5. {
  6. 	assert(q);
  7. 	q->head = q->tail = NULL;
  8. 	q->k = 0;
  9. }
  10.  
  11. void QueuePush(Queue* q, QDatatype data)
  12. {
  13. 	assert(q);
  14. 	QNode* tmp = (QNode*)malloc(sizeof(QNode));
  15. 	if (tmp == NULL)
  16. 	{
  17. 		perror("malloc fail");
  18. 		return;
  19. 	}
  20. 	tmp->_data = data;
  21. 	tmp->_next = NULL;
  22. 	if (q->tail == NULL)
  23. 	{
  24. 		q->head = q->tail = tmp;
  25. 	}
  26. 	else
  27. 	{
  28. 		q->tail->_next = tmp;
  29. 		q->tail = tmp;
  30. 	}
  31. 	q->k++;
  32. }
  33.  
  34. void QueuePop(Queue* q)
  35. {
  36. 	assert(q);
  37. 	assert(q->k > 0);
  38. 	QNode* next = q->head->_next;
  39. 	free(q->head);
  40. 	q->head = next;
  41. 	if (q->head == NULL)
  42. 	{
  43. 		q->tail = NULL;
  44. 	}
  45. 	q->k--;
  46. }
  47.  
  48. QDatatype QueueFront(Queue* q)
  49. {
  50. 	assert(q);
  51. 	assert(q->k > 0);
  52. 	return q->head->_data;
  53. }
  54.  
  55. QDatatype QueueBack(Queue* q)
  56. {
  57. 	assert(q);
  58. 	assert(q->k > 0);
  59. 	return q->tail->_data;
  60. }
  61.  
  62. int QueueSize(Queue* q)
  63. {
  64. 	assert(q);
  65. 	return q->k;
  66. }
  67.  
  68. bool QueueEmpty(Queue* q)
  69. {
  70. 	assert(q);
  71. 	return q->tail == NULL;
  72. }
  73.  
  74. void QueueDestroy(Queue* q)
  75. {
  76. 	assert(q);
  77. 	QNode* tmp = q->head;
  78. 	while (tmp)
  79. 	{
  80. 		QNode* next = tmp->_next;
  81. 		free(tmp);
  82. 		tmp = next;
  83. 	}
  84. 	q->k = 0;
  85. 	q->head = q->tail = NULL;
  86. }

3.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. //动态申请二叉树节点
  15. BTNode* CreateBinaryTreeNode(BTDataType data);
  16.  
  17. //分层的层序遍历
  18. void _BinaryTreeLevelOrder(BTNode* root);

4.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4. #include"queue.h"
  5.  
  6. //动态申请二叉树节点
  7. BTNode* CreateBinaryTreeNode(BTDataType data)
  8. {
  9. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  10. 	if (tmp == NULL)
  11. 	{
  12. 		perror("malloc fail");
  13. 		exit(-1);
  14. 	}
  15. 	tmp->data = data;
  16. 	tmp->leftchild = NULL;
  17. 	tmp->rightchild = NULL;
  18. 	return tmp;
  19. }
  20.  
  21. //分层的层序遍历
  22. void _BinaryTreeLevelOrder(BTNode* root)
  23. {
  24. 	Queue q;
  25. 	QueueInit(&q);
  26. 	QueuePush(&q, root);
  27. 	int size = 1;
  28. 	while (!QueueEmpty(&q))
  29. 	{
  30. 		while (size--)
  31. 		{
  32. 			BTNode* front = QueueFront(&q);
  33. 			printf("%c ", front->data);
  34. 			QueuePop(&q);
  35. 			if (front->leftchild)
  36. 			{
  37. 				QueuePush(&q, front->leftchild);
  38. 			}
  39. 			if (front->rightchild)
  40. 			{
  41. 				QueuePush(&q, front->rightchild);
  42. 			}
  43. 		}
  44. 		printf("\n");
  45. 		size = QueueSize(&q);
  46. 	}
  47. 	QueueDestroy(&q);
  48. }
  49.

5.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	BTNode* node1 = CreateBinaryTreeNode('A');
  6. 	BTNode* node2 = CreateBinaryTreeNode('B');
  7. 	BTNode* node3 = CreateBinaryTreeNode('C');
  8. 	BTNode* node4 = CreateBinaryTreeNode('D');
  9. 	BTNode* node5 = CreateBinaryTreeNode('E');
  10. 	BTNode* node6 = CreateBinaryTreeNode('F');
  11. 	BTNode* node7 = CreateBinaryTreeNode('G');
  12. 	BTNode* node8 = CreateBinaryTreeNode('H');
  13. 	BTNode* node9 = CreateBinaryTreeNode('I');
  14. 	node1->leftchild = node2;
  15. 	node1->rightchild = node6;
  16. 	node2->leftchild = node3;
  17. 	node3->leftchild = node4;
  18. 	node4->rightchild = node5;
  19. 	node6->leftchild = node7;
  20. 	node7->leftchild = node8;
  21. 	node8->rightchild = node9;
  22.  
  23. 	//分层的层序遍历
  24. 	 _BinaryTreeLevelOrder(node1);
  25. 	return 0;
  26. }

运行结果是没问题的：

 鼠鼠在这里顺便提一嘴，层序遍历是一种广度优先遍历（bfs）。

 2.二叉树节点个数

拿这棵树来说，节点个数是9个：

那我们该如何求呢？

当然我们可以用层序遍历，每出一个数据就计数一次，但是鼠鼠这里用的是递归的写法，思想是：当传入空树（就是传入节点指针为空指针）就返回0；不为空树就返回左子树节点个数+右子树节点个数+1即可。

我们看代码来体会一下：

  1. //二叉树节点个数
  2. int BinaryTreeSize(BTNode* root)
  3. {
  4. 	if (root == NULL)
  5. 	{
  6. 		return 0;
  7. 	}
  8. 	return  BinaryTreeSize(root->leftchild) + BinaryTreeSize(root->rightchild) + 1;
  9. }

 我们看看完整代码，3个文件放入同一个工程运行可出结果：

1.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. //动态申请二叉树节点
  15. BTNode* CreateBinaryTreeNode(BTDataType data);
  16.  
  17. //二叉树节点个数
  18. int BinaryTreeSize(BTNode* root);

2.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4.  
  5. //动态申请二叉树节点
  6. BTNode* CreateBinaryTreeNode(BTDataType data)
  7. {
  8. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  9. 	if (tmp == NULL)
  10. 	{
  11. 		perror("malloc fail");
  12. 		exit(-1);
  13. 	}
  14. 	tmp->data = data;
  15. 	tmp->leftchild = NULL;
  16. 	tmp->rightchild = NULL;
  17. 	return tmp;
  18. }
  19.  
  20. //二叉树节点个数
  21. int BinaryTreeSize(BTNode* root)
  22. {
  23. 	if (root == NULL)
  24. 	{
  25. 		return 0;
  26. 	}
  27. 	return  BinaryTreeSize(root->leftchild) + BinaryTreeSize(root->rightchild) + 1;
  28. }

3.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	BTNode* node1 = CreateBinaryTreeNode('A');
  6. 	BTNode* node2 = CreateBinaryTreeNode('B');
  7. 	BTNode* node3 = CreateBinaryTreeNode('C');
  8. 	BTNode* node4 = CreateBinaryTreeNode('D');
  9. 	BTNode* node5 = CreateBinaryTreeNode('E');
  10. 	BTNode* node6 = CreateBinaryTreeNode('F');
  11. 	BTNode* node7 = CreateBinaryTreeNode('G');
  12. 	BTNode* node8 = CreateBinaryTreeNode('H');
  13. 	BTNode* node9 = CreateBinaryTreeNode('I');
  14. 	node1->leftchild = node2;
  15. 	node1->rightchild = node6;
  16. 	node2->leftchild = node3;
  17. 	node3->leftchild = node4;
  18. 	node4->rightchild = node5;
  19. 	node6->leftchild = node7;
  20. 	node7->leftchild = node8;
  21. 	node8->rightchild = node9;
  22.  
  23. 	//二叉树节点个数
  24. 	printf("%d\n", BinaryTreeSize(node1));
  25. 	return 0;
  26. }

看看运行结果，拿捏了：

 3.二叉树叶子节点个数

还是用这棵树来说，这棵树的叶子节点是节点E、I，个数是2。

递归的方法很简单，如果传入空树（就是传入的节点指针是空指针）就返回0；如果传入的树没有左右子节点那么返回1；返回左子树叶子节点个数+右子树叶子节点个数即可。基于这个思想，代码如下：

  1. //二叉树叶子节点个数
  2. int BinaryTreeLeafSize(BTNode* root)
  3. {
  4. 	if (root == NULL)
  5. 	{
  6. 		return 0;
  7. 	}
  8. 	if (root->leftchild == NULL && root->rightchild == NULL)
  9. 	{
  10. 		return 1;
  11. 	}
  12. 	return BinaryTreeLeafSize(root->leftchild) + BinaryTreeLeafSize(root->rightchild);
  13. }

完整代码是三个文件，将三个文件放入同一个工程下面运行可得结果：

1.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. //动态申请二叉树节点
  15. BTNode* CreateBinaryTreeNode(BTDataType data);
  16.  
  17. //二叉树叶子节点个数
  18. int BinaryTreeLeafSize(BTNode* root);

2.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4.  
  5. //动态申请二叉树节点
  6. BTNode* CreateBinaryTreeNode(BTDataType data)
  7. {
  8. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  9. 	if (tmp == NULL)
  10. 	{
  11. 		perror("malloc fail");
  12. 		exit(-1);
  13. 	}
  14. 	tmp->data = data;
  15. 	tmp->leftchild = NULL;
  16. 	tmp->rightchild = NULL;
  17. 	return tmp;
  18. }
  19.  
  20. //二叉树叶子节点个数
  21. int BinaryTreeLeafSize(BTNode* root)
  22. {
  23. 	if (root == NULL)
  24. 	{
  25. 		return 0;
  26. 	}
  27. 	if (root->leftchild == NULL && root->rightchild == NULL)
  28. 	{
  29. 		return 1;
  30. 	}
  31. 	return BinaryTreeLeafSize(root->leftchild) + BinaryTreeLeafSize(root->rightchild);
  32. }

3.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	BTNode* node1 = CreateBinaryTreeNode('A');
  6. 	BTNode* node2 = CreateBinaryTreeNode('B');
  7. 	BTNode* node3 = CreateBinaryTreeNode('C');
  8. 	BTNode* node4 = CreateBinaryTreeNode('D');
  9. 	BTNode* node5 = CreateBinaryTreeNode('E');
  10. 	BTNode* node6 = CreateBinaryTreeNode('F');
  11. 	BTNode* node7 = CreateBinaryTreeNode('G');
  12. 	BTNode* node8 = CreateBinaryTreeNode('H');
  13. 	BTNode* node9 = CreateBinaryTreeNode('I');
  14. 	node1->leftchild = node2;
  15. 	node1->rightchild = node6;
  16. 	node2->leftchild = node3;
  17. 	node3->leftchild = node4;
  18. 	node4->rightchild = node5;
  19. 	node6->leftchild = node7;
  20. 	node7->leftchild = node8;
  21. 	node8->rightchild = node9;
  22.  
  23. 	//二叉树叶子节点个数
  24. 	printf("%d\n", BinaryTreeLeafSize(node1));
  25. 	return 0;
  26. }

运行结果也是轻松拿捏啊：

 4.二叉树第k层节点个数

同样的，我们拿这棵树来说，第1层有1个节点，其他层都有2个节点；

拿以B节点为根节点的树来说，全部层都只有1个节点。

 递归的思想也很简单：如果传入的是空树（也就是传入的节点地址为空指针），我们返回0；如果不为空树我们分两种情况：第一种找第1层节点个数的话我们返回1（第1层只有一个根节点必然节点数为1），第二种找第K层节点个数的话相当于找左子树第K-1层节点个数+右子树第K-1层节点个数。好捏，看代码：

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

那么完整代码如下，放入同一个工程中哦：

1.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. //动态申请二叉树节点
  15. BTNode* CreateBinaryTreeNode(BTDataType data);
  16.  
  17. // 二叉树第k层节点个数
  18. int BinaryTreeLevelKSize(BTNode* root, int k);

2.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4.  
  5. //动态申请二叉树节点
  6. BTNode* CreateBinaryTreeNode(BTDataType data)
  7. {
  8. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  9. 	if (tmp == NULL)
  10. 	{
  11. 		perror("malloc fail");
  12. 		exit(-1);
  13. 	}
  14. 	tmp->data = data;
  15. 	tmp->leftchild = NULL;
  16. 	tmp->rightchild = NULL;
  17. 	return tmp;
  18. }
  19.  
  20. // 二叉树第k层节点个数
  21. int BinaryTreeLevelKSize(BTNode* root, int k)
  22. {
  23. 	if (root == NULL)
  24. 	{
  25. 		return 0;
  26. 	}
  27. 	if (k == 1)
  28. 	{
  29. 		return 1;
  30. 	}
  31. 	return BinaryTreeLevelKSize(root->leftchild, k - 1) + BinaryTreeLevelKSize(root->rightchild, k - 1);
  32. }
  33.

3.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	BTNode* node1 = CreateBinaryTreeNode('A');
  6. 	BTNode* node2 = CreateBinaryTreeNode('B');
  7. 	BTNode* node3 = CreateBinaryTreeNode('C');
  8. 	BTNode* node4 = CreateBinaryTreeNode('D');
  9. 	BTNode* node5 = CreateBinaryTreeNode('E');
  10. 	BTNode* node6 = CreateBinaryTreeNode('F');
  11. 	BTNode* node7 = CreateBinaryTreeNode('G');
  12. 	BTNode* node8 = CreateBinaryTreeNode('H');
  13. 	BTNode* node9 = CreateBinaryTreeNode('I');
  14. 	node1->leftchild = node2;
  15. 	node1->rightchild = node6;
  16. 	node2->leftchild = node3;
  17. 	node3->leftchild = node4;
  18. 	node4->rightchild = node5;
  19. 	node6->leftchild = node7;
  20. 	node7->leftchild = node8;
  21. 	node8->rightchild = node9;
  22.  
  23. 	// 二叉树第k层节点个数
  24. 	printf("%d %d\n", BinaryTreeLevelKSize(node1, 1), BinaryTreeLevelKSize(node1, 3));
  25. 	printf("%d\n", BinaryTreeLevelKSize(node2, 3));
  26. 	return 0;
  27. }

看看运行结果：

5.二叉树高度

还是拿这颗二叉树来说，高度为5。

递归实现来说思想就是如果传入的是空树，我们返回0，不为空树的话我们返回左右子树高度中较大者+1（+1是为了加上根节点那层）。

  1. //二叉树高度
  2. int BinaryTreeHeight(BTNode* root)
  3. {
  4. 	if (root == NULL)
  5. 	{
  6. 		return 0;
  7. 	}
  8. 	return (int)fmax(BinaryTreeHeight(root->leftchild), BinaryTreeHeight(root->rightchild)) + 1;
  9. }

完整代码看一看，放入同一个工程可看结果哦：

1.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<math.h>
  5.  
  6. typedef char BTDataType;
  7.  
  8. typedef struct BTNode
  9. {
  10. 	BTDataType data;
  11. 	struct BTNode* leftchild;
  12. 	struct BTNode* rightchild;
  13. }BTNode;
  14.  
  15. //动态申请二叉树节点
  16. BTNode* CreateBinaryTreeNode(BTDataType data);
  17.  
  18. //二叉树高度
  19. int BinaryTreeHeight(BTNode* root);

这里要注意需要包含头文件<math.h>，因为我们用到了fmax这个函数。

2.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4.  
  5. //动态申请二叉树节点
  6. BTNode* CreateBinaryTreeNode(BTDataType data)
  7. {
  8. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  9. 	if (tmp == NULL)
  10. 	{
  11. 		perror("malloc fail");
  12. 		exit(-1);
  13. 	}
  14. 	tmp->data = data;
  15. 	tmp->leftchild = NULL;
  16. 	tmp->rightchild = NULL;
  17. 	return tmp;
  18. }
  19.  
  20. //二叉树高度
  21. int BinaryTreeHeight(BTNode* root)
  22. {
  23. 	if (root == NULL)
  24. 	{
  25. 		return 0;
  26. 	}
  27. 	return (int)fmax(BinaryTreeHeight(root->leftchild), BinaryTreeHeight(root->rightchild)) + 1;
  28. }

3.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	BTNode* node1 = CreateBinaryTreeNode('A');
  6. 	BTNode* node2 = CreateBinaryTreeNode('B');
  7. 	BTNode* node3 = CreateBinaryTreeNode('C');
  8. 	BTNode* node4 = CreateBinaryTreeNode('D');
  9. 	BTNode* node5 = CreateBinaryTreeNode('E');
  10. 	BTNode* node6 = CreateBinaryTreeNode('F');
  11. 	BTNode* node7 = CreateBinaryTreeNode('G');
  12. 	BTNode* node8 = CreateBinaryTreeNode('H');
  13. 	BTNode* node9 = CreateBinaryTreeNode('I');
  14. 	node1->leftchild = node2;
  15. 	node1->rightchild = node6;
  16. 	node2->leftchild = node3;
  17. 	node3->leftchild = node4;
  18. 	node4->rightchild = node5;
  19. 	node6->leftchild = node7;
  20. 	node7->leftchild = node8;
  21. 	node8->rightchild = node9;
  22.  
  23. 	// 二叉树高度
  24. 	printf("%d\n", BinaryTreeHeight(node1));
  25. 	return 0;
  26. }

 看好了，运行结果我只展示一次：

 6.二叉树查找值为x的节点

找值为x的节点很简单，递归写法来说就是：如果传入空树，返回空指针：如果根节点就是值为x的节点，我们返回这个节点的地址；如果根节点的值不是x，我们在左子树找，找到返回，找不到就去右子树找，找到返回，找不到就返回空指针。

  1. // 二叉树查找值为x的节点
  2. BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
  3. {
  4. 	if (root == NULL)
  5. 	{
  6. 		return NULL;
  7. 	}
  8. 	if (root->data == x)
  9. 	{
  10. 		return root;
  11. 	}
  12. 	BTNode* find1 = BinaryTreeFind(root->leftchild, x);
  13. 	if (find1)
  14. 	{
  15. 		return find1;
  16. 	}
  17. 	BTNode* find2 = BinaryTreeFind(root->rightchild, x);
  18. 	if (find2)
  19. 	{
  20. 		return find2;
  21. 	}
  22. 	return NULL;
  23. }

我们还是用这颗树来试试：

 完整代码如下：

1.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. //动态申请二叉树节点
  15. BTNode* CreateBinaryTreeNode(BTDataType data);
  16.  
  17. // 二叉树查找值为x的节点
  18. BTNode* BinaryTreeFind(BTNode* root, BTDataType x);

2.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4.  
  5. //动态申请二叉树节点
  6. BTNode* CreateBinaryTreeNode(BTDataType data)
  7. {
  8. 	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
  9. 	if (tmp == NULL)
  10. 	{
  11. 		perror("malloc fail");
  12. 		exit(-1);
  13. 	}
  14. 	tmp->data = data;
  15. 	tmp->leftchild = NULL;
  16. 	tmp->rightchild = NULL;
  17. 	return tmp;
  18. }
  19.  
  20. // 二叉树查找值为x的节点
  21. BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
  22. {
  23. 	if (root == NULL)
  24. 	{
  25. 		return NULL;
  26. 	}
  27. 	if (root->data == x)
  28. 	{
  29. 		return root;
  30. 	}
  31. 	BTNode* find1 = BinaryTreeFind(root->leftchild, x);
  32. 	if (find1)
  33. 	{
  34. 		return find1;
  35. 	}
  36. 	BTNode* find2 = BinaryTreeFind(root->rightchild, x);
  37. 	if (find2)
  38. 	{
  39. 		return find2;
  40. 	}
  41. 	return NULL;
  42. }

3.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	BTNode* node1 = CreateBinaryTreeNode('A');
  6. 	BTNode* node2 = CreateBinaryTreeNode('B');
  7. 	BTNode* node3 = CreateBinaryTreeNode('C');
  8. 	BTNode* node4 = CreateBinaryTreeNode('D');
  9. 	BTNode* node5 = CreateBinaryTreeNode('E');
  10. 	BTNode* node6 = CreateBinaryTreeNode('F');
  11. 	BTNode* node7 = CreateBinaryTreeNode('G');
  12. 	BTNode* node8 = CreateBinaryTreeNode('H');
  13. 	BTNode* node9 = CreateBinaryTreeNode('I');
  14. 	node1->leftchild = node2;
  15. 	node1->rightchild = node6;
  16. 	node2->leftchild = node3;
  17. 	node3->leftchild = node4;
  18. 	node4->rightchild = node5;
  19. 	node6->leftchild = node7;
  20. 	node7->leftchild = node8;
  21. 	node8->rightchild = node9;
  22.  
  23. 	// 二叉树查找值为x的节点
  24. 	if (BinaryTreeFind(node1, 'H'))
  25. 	{
  26. 		printf("%c\n", BinaryTreeFind(node1, 'H')->data);
  27.  
  28. 	}
  29. 	else
  30. 	{
  31. 		printf("找不到\n");
  32. 	}
  33. 	return 0;
  34. }

 运行结果也是预料之中：

 7.通过前序遍历的数组构建二叉树, 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"

好的呀，我们前面讲过链式二叉树一般不用硬编码的方式构建，一般用递归构建，那么鼠鼠现在就来浅浅介绍一下！

这里的意思就是写一个用递归实现的函数，该函数能实现输入一组二叉树前序遍历得到的数组就能将这棵二叉树构建出来并返回二叉树指针。

用递归实现的思想就是遍历数组元素，若为‘#’就返回空指针；若不为'#'就动态申请一个节点的空间并将该元素存入申请的空间当中，这个空间就是根节点，接着构建左子树和右子树就行。

  1. /*通过前序遍历的数组构建二叉树,
  2. 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"*/
  3. BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
  4. {
  5. 	if (*(a + *pi) == '#')
  6. 	{
  7. 		(*pi)++;
  8. 		return NULL;
  9. 	}
  10. 	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
  11. 	if (root == NULL)
  12. 	{
  13. 		perror("malloc fail");
  14. 		exit(-1);
  15. 	}
  16. 	root->data = a[*pi];
  17. 	(*pi)++;
  18. 	root->leftchild = BinaryTreeCreate(a, pi);
  19. 	root->rightchild = BinaryTreeCreate(a, pi);
  20. 	return root;
  21. }

为了印证我们确实是构建出来了这棵树，鼠鼠构建出来后用前序遍历依次访问节点并打印出来，那么完整代码如下三个文件：

1.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4.  
  5. typedef char BTDataType;
  6.  
  7. typedef struct BTNode
  8. {
  9. 	BTDataType data;
  10. 	struct BTNode* leftchild;
  11. 	struct BTNode* rightchild;
  12. }BTNode;
  13.  
  14. /*通过前序遍历的数组构建二叉树,
  15. 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"*/
  16. BTNode* BinaryTreeCreate(BTDataType* a, int* pi);
  17.  
  18. // 二叉树前序遍历
  19. void BinaryTreePrevOrder(BTNode* root);

 2.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4.  
  5.  
  6. /*通过前序遍历的数组构建二叉树,
  7. 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"*/
  8. BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
  9. {
  10. 	if (*(a + *pi) == '#')
  11. 	{
  12. 		(*pi)++;
  13. 		return NULL;
  14. 	}
  15. 	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
  16. 	if (root == NULL)
  17. 	{
  18. 		perror("malloc fail");
  19. 		exit(-1);
  20. 	}
  21. 	root->data = a[*pi];
  22. 	(*pi)++;
  23. 	root->leftchild = BinaryTreeCreate(a, pi);
  24. 	root->rightchild = BinaryTreeCreate(a, pi);
  25. 	return root;
  26. }
  27.  
  28. // 二叉树前序遍历
  29. void BinaryTreePrevOrder(BTNode* root)
  30. {
  31. 	if (root == NULL)
  32. 	{
  33. 		printf("# ");
  34. 		return;
  35. 	}
  36. 	//根节点
  37. 	printf("%c ", root->data);
  38. 	//左子树
  39. 	BinaryTreePrevOrder(root->leftchild);
  40. 	//右子树
  41. 	BinaryTreePrevOrder(root->rightchild);
  42. }
  43.

3.test.c

  1. #include"BinaryTree.h"
  2.  
  3. int main()
  4. {
  5. 	/*通过前序遍历的数组构建二叉树,
  6. 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"*/
  7. 	char a[] = "ABD##E#H##CF##G##";
  8. 	int i = 0;
  9. 	BTNode* root = BinaryTreeCreate(a, &i);
  10. 	BinaryTreePrevOrder(root);
  11. 	return 0;
  12. }

 运行结果表明确实是将这棵二叉树构建出来了：

那么这棵二叉树的想象图我给读者老爷画一画呀：

8. 判断二叉树是否是完全二叉树

我们判断二叉树是否是完全二叉树可以有很多方法，鼠鼠这里利用到了层序遍历的思想，但不同的是当左孩子节点或右孩子节点地址为空指针也一样入队列，当出队列遇到空指针就停止。此时若队列中还有非空指针就不是完全二叉树，反之就是完全二叉树。

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

 我们拿上面递归构建的二叉树来试试这个代码，可以看出这棵二叉树不是完全二叉树：

那么试验这棵二叉树所需5个文件如下，有兴趣的老爷可以试试：

1.queue.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<assert.h>
  4. #include<stdlib.h>
  5. #include<stdbool.h>
  6.  
  7. #include"BinaryTree.h"
  8.  
  9. typedef BTNode* QDatatype;
  10.  
  11. typedef struct QNode
  12. {
  13. 	QDatatype _data;
  14. 	struct  QNode* _next;
  15. }QNode;
  16.  
  17. typedef struct Queue
  18. {
  19. 	int k;
  20. 	QNode* head;
  21. 	QNode* tail;
  22. }Queue;
  23.  
  24. //初始化队列
  25. void QueueInit(Queue* q);
  26.  
  27. //队尾入数据
  28. void QueuePush(Queue* q, QDatatype data);
  29.  
  30. //对头出数据
  31. void QueuePop(Queue* q);
  32.  
  33. //获取队列对头元素
  34. QDatatype QueueFront(Queue* q);
  35.  
  36. //获取队列队尾元素
  37. QDatatype QueueBack(Queue* q);
  38.  
  39. //获取队列中有效元素个数
  40. int QueueSize(Queue* q);
  41.  
  42. //检测队列是否为空，如果为空返回非零结果，非空返回0
  43. bool QueueEmpty(Queue* q);
  44.  
  45. //销毁队列
  46. void QueueDestroy(Queue* q);

2.queue.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include"queue.h"
  3.  
  4. void QueueInit(Queue* q)
  5. {
  6. 	assert(q);
  7. 	q->head = q->tail = NULL;
  8. 	q->k = 0;
  9. }
  10.  
  11. void QueuePush(Queue* q, QDatatype data)
  12. {
  13. 	assert(q);
  14. 	QNode* tmp = (QNode*)malloc(sizeof(QNode));
  15. 	if (tmp == NULL)
  16. 	{
  17. 		perror("malloc fail");
  18. 		return;
  19. 	}
  20. 	tmp->_data = data;
  21. 	tmp->_next = NULL;
  22. 	if (q->tail == NULL)
  23. 	{
  24. 		q->head = q->tail = tmp;
  25. 	}
  26. 	else
  27. 	{
  28. 		q->tail->_next = tmp;
  29. 		q->tail = tmp;
  30. 	}
  31. 	q->k++;
  32. }
  33.  
  34. void QueuePop(Queue* q)
  35. {
  36. 	assert(q);
  37. 	assert(q->k > 0);
  38. 	QNode* next = q->head->_next;
  39. 	free(q->head);
  40. 	q->head = next;
  41. 	if (q->head == NULL)
  42. 	{
  43. 		q->tail = NULL;
  44. 	}
  45. 	q->k--;
  46. }
  47.  
  48. QDatatype QueueFront(Queue* q)
  49. {
  50. 	assert(q);
  51. 	assert(q->k > 0);
  52. 	return q->head->_data;
  53. }
  54.  
  55. QDatatype QueueBack(Queue* q)
  56. {
  57. 	assert(q);
  58. 	assert(q->k > 0);
  59. 	return q->tail->_data;
  60. }
  61.  
  62. int QueueSize(Queue* q)
  63. {
  64. 	assert(q);
  65. 	return q->k;
  66. }
  67.  
  68. bool QueueEmpty(Queue* q)
  69. {
  70. 	assert(q);
  71. 	return q->tail == NULL;
  72. }
  73.  
  74. void QueueDestroy(Queue* q)
  75. {
  76. 	assert(q);
  77. 	QNode* tmp = q->head;
  78. 	while (tmp)
  79. 	{
  80. 		QNode* next = tmp->_next;
  81. 		free(tmp);
  82. 		tmp = next;
  83. 	}
  84. 	q->k = 0;
  85. 	q->head = q->tail = NULL;
  86. }

3.BinaryTree.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<stdbool.h>
  5.  
  6. typedef char BTDataType;
  7.  
  8. typedef struct BTNode
  9. {
  10. 	BTDataType data;
  11. 	struct BTNode* leftchild;
  12. 	struct BTNode* rightchild;
  13. }BTNode;
  14.  
  15. /*通过前序遍历的数组构建二叉树,
  16. 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"*/
  17. BTNode* BinaryTreeCreate(BTDataType* a, int* pi);
  18.  
  19. // 判断二叉树是否是完全二叉树
  20. bool BinaryTreeComplete(BTNode* root);
  21.

4.BinaryTree.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include"BinaryTree.h"
  4. #include"queue.h"
  5.  
  6.  
  7. /*通过前序遍历的数组构建二叉树,
  8. 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"*/
  9. BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
  10. {
  11. 	if (*(a + *pi) == '#')
  12. 	{
  13. 		(*pi)++;
  14. 		return NULL;
  15. 	}
  16. 	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
  17. 	if (root == NULL)
  18. 	{
  19. 		perror("malloc fail");
  20. 		exit(-1);
  21. 	}
  22. 	root->data = a[*pi];
  23. 	(*pi)++;
  24. 	root->leftchild = BinaryTreeCreate(a, pi);
  25. 	root->rightchild = BinaryTreeCreate(a, pi);
  26. 	return root;
  27. }
  28.  
  29. // 判断二叉树是否是完全二叉树
  30. bool BinaryTreeComplete(BTNode* root)
  31. {
  32. 	Queue q;
  33. 	QueueInit(&q);
  34. 	QueuePush(&q, root);
  35. 	while (!QueueEmpty(&q))
  36. 	{
  37. 		BTNode* front = QueueFront(&q);
  38. 		QueuePop(&q);
  39. 		if (front == NULL)
  40. 		{
  41. 			break;
  42. 		}
  43. 		QueuePush(&q, front->leftchild);
  44. 		QueuePush(&q, front->rightchild);
  45. 	}
  46. 	while (!QueueEmpty(&q))
  47. 	{
  48. 		BTNode* front = QueueFront(&q);
  49. 		QueuePop(&q);
  50. 		if (front)
  51. 		{
  52. 			return false;
  53. 		}
  54. 	}
  55. 	return true;
  56. 	QueueDestroy(&q);
  57. }

5.test.c

  1. #include"BinaryTree.h"
  2. #include"queue.h"
  3.  
  4. int main()
  5. {
  6. 	/*通过前序遍历的数组构建二叉树,
  7. 叶节点子节点用'#'表示，如"ABD##E#H##CF##G##"*/
  8. 	char a[] = "ABD##E#H##CF##G##";
  9. 	int i = 0;
  10. 	BTNode* root = BinaryTreeCreate(a, &i);
  11. 	if (BinaryTreeComplete(root))
  12. 	{
  13. 		printf("是完全二叉树\n");
  14. 	}
  15. 	else
  16. 	{
  17. 		printf("不是完全二叉树\n");
  18. 	}
  19. 	return 0;
  20. }

 运行结果确实如我们所料：

当我们换一棵完全二叉树来测试时结果也没问题，代码只要更改main函数的数组a，将数组a改成完全二叉树前序遍历的数组即可，我们来看看：

 没问题的！

9.二叉树销毁

二叉树销毁也用递归来完成，最好的办法时采用后续，因为根节点最后销毁的话方便我们找到左右子树，那么思想就是：先销毁左子树，再销毁右子树，最后销毁根节点即可。

  1. //二叉树销毁
  2. void BinaryTreeDestroy(BTNode* root)
  3. {
  4. 	if (root == NULL)
  5. 	{
  6. 		return;
  7. 	}
  8. 	//左子树
  9. 	BinaryTreeDestroy(root->leftchild);
  10. 	//右子树
  11. 	BinaryTreeDestroy(root->rightchild);
  12. 	//根节点
  13. 	free(root);
  14. }

这个我们就不测试了！ 

 10.二叉树的性质

最后鼠鼠介绍一个二叉树的性质，挺重要的：对任何一棵二叉树, 如果度为0其叶结点个数为n， 度为2的分支结点个数为k，则有n=k+1。

比如这道题就用到了这个性质：

3.在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2
答案是：A

 因为是二叉树，那么二叉树节点的度只可能为0、1和2。那么设度为0的节点（即叶子节点）个数为X，设度为1的节点个数为Y，设度为2的节点个数为Z，那么X+Y+Z=X+Y+(X-1)=2X+Y-1=2n。

又因为是完全二叉树，那么度为1的节点个数要么是0个，要么是1个。当Y=0时，不可能满足2Z+Y+1=2n，因为2n时偶数；所有Y肯定为1，那么代入2X+1-1=2n即可得出X=n。

感谢阅读，欢迎斧正！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/396879
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号