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

    目录

    一，二叉树的链式结构

    二，二叉链的接口实现

            1，二叉链的创建

            2，接口函数

            3，动态创立新结点

            4，创建二叉树

            5，前序遍历

            6，中序遍历

            7，后序遍历

    三，结点个数以及高度等

            1，接口函数

            2，结点个数

            3，叶子结点个数

            4，二叉树高度

            5，二叉树第k层结点个数

            6，二叉树查找值为x的结点

    一，二叉树的链式结构

    二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系；

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

    链式结构又分为二叉链和三叉链，这里我们学习二叉链；

     二叉树是：

    1，空树

    2，非空：根节点，根节点的左子树、根节点的右子树组成的。

    从图示中可以看出，二叉树定义是递归式的也称递归树，因此后序基本操作中基本都是按照该概念实现的；

     二叉链结构图示；

    二，二叉链的接口实现

            1，二叉链的创建

    1. typedef int BTDataType;
    2. //二叉链
    3. typedef struct BinaryTreeNode
    4. {
    5. 	BTDataType data; // 当前结点值域	
    6. 	struct BinaryTreeNode* left; // 指向当前结点左孩子
    7. 	struct BinaryTreeNode* right; // 指向当前结点右孩子
    8. }BTNode;

    首先创建一个结构体表示二叉链，data是当前结点的值域，BTDataType是储存的值的数据类型；

    left是指向当前结点左孩子，right是指向当前结点右孩子；

    这里的BTDataType是int的重命名，也可以说是数据类型的重命名，这样统一化方便后续更改；

            2，接口函数

    1. //动态创立新结点
    2. BTNode* BuyNode(BTDataType x);
    3. //创建二叉树
    4. BTNode* GreatBTree();
    5. //前序遍历
    6. void PrevOrder(BTNode* root);
    7. //中序遍历
    8. void InOrder(BTNode* root);
    9. //后序遍历
    10. void PostOrder(BTNode* root);

    这是以上要实现的接口函数；

            3，动态创立新结点

    1. //动态创立新结点
    2. BTNode* BuyNode(BTDataType x)
    3. {
    4. 	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
    5. 	assert(newnode);
    6. 	newnode->data = x;
    7. 	newnode->left = NULL;
    8. 	newnode->right = NULL;
    9. 	return newnode;
    10. }

    后面创立新结点时直接调用此函数，一定要向堆区申请空间，这样函数结束空间会保留不会被回收；

    将data赋新值，left与right都指向空，再返回结点指针即可；

            4，创建二叉树

    1. //创建二叉树
    2. BTNode* GreatBTree()
    3. {
    4. 	BTNode* node1 = BuyNode(1);
    5. 	BTNode* node2 = BuyNode(2);
    6. 	BTNode* node3 = BuyNode(3);
    7. 	BTNode* node4 = BuyNode(4);
    8. 	BTNode* node5 = BuyNode(5);
    9. 	BTNode* node6 = BuyNode(6);
    10.  
    11. 	node1->left = node2;
    12. 	node1->right = node4;
    13. 	node2->left = node3;
    14. 	node4->left = node5;
    15. 	node4->right = node6;
    16.  
    17. 	return node1;
    18. }

    然后我们申请结点来构造二叉树，通过链接将新结点链接起来；

    创建的二叉树结构图示如下：

            5，前序遍历

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

    二叉树的前序，中序，后续遍历都是同一种思路：

    1. 前序遍历(Preorder Traversal 亦称先序遍历)——根结点---->左子树--->右子树

    2. 中序遍历(Inorder Traversal)——左子树--->根结点--->右子树

    3. 后序遍历(Postorder Traversal)——左子树--->右子树--->根结点

    这里要用到递归思想：这里NULL用N表示，建议画图来理解，一层一层遍历下去；

    前序遍历：

    先访问根结点（1）然后访问其左子树（2）；打印 1

    此时根结点为（2）然后访问其左子树（3）；打印1 2

    此时根结点为（3）然后访问其左子树（NULL）；打印1 2 3

    此时根结点为（NULL）return NULL到（3），然后访问（3）的右子树（NULL）；打印1 2 3 N

    此时根结点为（NULL）return NULL到（3），此时对（3）也就是对（2）的左子树的访问结束了，然后访问（2）的右子树（NULL)；打印1 2 3 N N

    此时根结点为（NULL）return NULL到（2），此时对（2）也就是对（1）的左子树访问结束了，然后访问（1）的右子树（4）；打印1 2 3 N N N

    此时根结点为（4）然后访问其左子树（5）；打印1 2 3 N N N 4

    此时根结点为（5）然后访问其左子树（NULL）；打印1 2 3 N N N 4 5

    此时根结点为（NULL）return NULL到（5）然后访问（5）的右子树（NULL）；打印1 2 3 N N N 4 5 N

    此时根结点为（NULL）return NULL到（5）此时对（5）也就是对（4）的左子树的访问结束了，然后访问（4）的右子树（6）；打印 1 2 3 N N N 4 5 N N

    此时根结点为（6）然后访问其左子树（NULL）；打印1 2 3 N N N 4 5 N N 6

    此时根结点为（NULL）return NULL到（6）然后访问（6）的右子树（NULL）；打印1 2 3 N N N 4 5 N N 6 N

    此时根结点为（NULL）return NULL到（6），此时对（6）也就是对（4）的右子树的访问结束了，此时对（4）也就是对（1）的右子树的访问结束了，此时对（1）的访问也结束了，前序遍历也就结束了；打印1 2 3 N N N 4 5 N N 6 N N

    图解思路示例：

        

    1. BTNode* root = GreatBTree();
    2. //前序遍历
    3. PrevOrder(root);

    这就是前序遍历；

            6，中序遍历

    1. //中序遍历
    2. void InOrder(BTNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		printf("N ");
    7. 		return;
    8. 	}
    9.  
    10. 	InOrder(root->left);
    11. 	printf("%d ", root->data);
    12. 	InOrder(root->right);
    13. }

    中序遍历：左子树--->根结点--->右子树

    跟前序遍历思路一致，就是换了一下访问的顺序，按照前序遍历的思路来就完事了；

    1. //中序遍历
    2. InOrder(root);
    3. printf("\n");

            7，后序遍历

    1. //后序遍历
    2. void PostOrder(BTNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		printf("N ");
    7. 		return;
    8. 	}
    9.  
    10. 	PostOrder(root->left);
    11. 	PostOrder(root->right);
    12. 	printf("%d ", root->data);
    13. }

    后序遍历：左子树--->右子树--->根结点

    思路还是一致的，就是换了一下访问顺序，前，中，后序遍历的思路都是一致的，只要搞清楚其中一个就全部拿捏了；

    1. //后续遍历
    2. PostOrder(root);
    3. printf("\n");

     这里对二叉链的基础遍历就实现完全了，有人说还有一个层序遍历，这个遍历需要用到队列，目前C语言阶段实现太过于繁琐，后序博主会补上；

    三，结点个数以及高度等

    像此类问题也都是递归问题，更加看重我们对函数栈帧的理解；

            1，接口函数

    1. //结点个数
    2. int	SumNode(BTNode* root);
    3. //叶子结点个数
    4. int LeafNode(BTNode* root);
    5. //二叉树高度
    6. int HeightTree(BTNode* root);
    7. //二叉树第k层结点个数
    8. int BTreeLeveSize(BTNode* root, int k);
    9. //二叉树查找值为x的结点
    10. BTNode* BTreeFine(BTNode* root, int x);

    以上是要实现的函数；

            2，结点个数

    1. //结点个数
    2. int SumNode(BTNode* root)
    3. {
    4. 	return root == NULL ? 0 : SumNode(root->left) + SumNode(root->right) + 1;
    5. }

    递归其实说难也难，说不难也不难，是有技巧在里面的；

    1，大事化小：根结点为（1）的二叉树的结点总和==>左子树（2）的结点总和加上右子树（4）的结点总和再加上本身的结点个数1，然后根结点为（2）的结点总和==>左子树（3）的总和加上NULL加1，这就是规律；【（1）=（2）+（4）+1 】

    2，结束条件，当结点为NULL时返回0；

    1. //结点个数
    2. printf("%d\n", SumNode(root));

            3，叶子结点个数

    1. //叶子结点个数
    2. int LeafNode(BTNode* 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. 	else
    13. 	{
    14. 		return LeafNode(root->left) + LeafNode(root->right);
    15. 	}
    16. }

     

    大事化小：求根结点为（1）的二叉树的叶子节点的个数==>其左子树（2）加上其右子树（4）的叶子节点的个数；【（1）=（2）+（4）】

    结束条件：当结点为NULL时返回0，当结点的左右子树都为NULL时返回1；

            4，二叉树高度

    1. //二叉树高度
    2. int HeightTree(BTNode* root)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return 0;
    7. 	}
    8. 	int left = HeightTree(root->left);
    9. 	int right = HeightTree(root->right);
    10. 	return left > right ? left + 1 : right + 1;
    11. }

    大事化小：求根结点为（1）的二叉树的高度==>其左子树（2）与右子树（4）中高的一颗的高度加上本身的高度1；【（1）=（2）>（4）？（2）+1：（4）+1 】

    结束条件：当结点为NULL时返回0；

    1. //二叉树高度
    2. printf("%d\n", HeightTree(root));

            5，二叉树第k层结点个数

    1. //二叉树第k层结点个数
    2. int BTreeLeveSize(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 BTreeLeveSize(root->left, k - 1)  + BTreeLeveSize(root->right, k - 1);
    13. }

    大事化小：求根结点为（1）的二叉树第K层的结点个数==>其左子树（2）加上右子树（4）中第K-1层结点的个数；【（1）=（2）+（4）】

    结束条件：当结点为NULL时返回0，当K等于1时返回1；

    1. //二叉树第k层结点个数
    2. printf("%d\n", BTreeLeveSize(root,3));

            6，二叉树查找值为x的结点

    1. //二叉树查找值为x的结点
    2. BTNode* BTreeFine(BTNode* root, int x)
    3. {
    4. 	if (root == NULL)
    5. 	{
    6. 		return NULL;
    7. 	}
    8. 	if (root->data == x)
    9. 	{
    10. 		return root;
    11. 	}
    12. 	if (BTreeFine(root->left, x) == NULL)
    13. 	{
    14. 		return BTreeFine(root->right, x);
    15. 	}
    16. 	else
    17. 	{
    18. 		return BTreeFine(root->left, x);
    19. 	}
    20. }

    大事化小：查找根结点为（1）的二叉树中值为x的结点==>查找其左子树（2）与右子树（4）中值为x的结点；

    结束条件：当结点为NULL时返回NULL，当结点的值为x时返回该结点；

    思路：所以当其中一个子树不为NULL时就是所求的结点，如果左子树不为空则返回左子树的结点，否则返回右子树的结点，如果左右都为空那也返回右子树的结点；

    1. //二叉树查找值为x的结点
    2. BTNode* ret = BTreeFine(root, 6);
    3. printf("%d\n", ret->data);
    4.  
    5. ret = BTreeFine(root, 3);
    6. printf("%d\n", ret->data);

    到这里就结束了，通过这些题目也充分的认识了二叉树（递归树），这就是递归算法，还是要多画图来理解，递归基层的知识就是函数栈帧的创建与销毁；

    第三阶段就到这里了，这阶段带大家了解一下二叉树（递归树）的递归思想；

    后面博主会陆续更新；

    如有不足之处欢迎来补充交流！

    完结。。

  • 相关阅读:
    1 数据分析概述与职业操守
    享元模式模式简介
    MapReduce的Partition和OutputFormat
    R语言数据分析案例：探索在线零售数据集
    【网络协议】 TCP与UDP协议区别及应用场景深度分析
    GDB用法
    Maven仓库依赖报错
    C++学习day1
    ffmpeg filter amix混音实现
    【模板】自适应辛普森积分
  • 原文地址：https://blog.csdn.net/m0_71676870/article/details/132839828