• 链式二叉树的基本操作(C语言实现)

    目录

    一、链式二叉树的创建

    1.1 定义节点结构

    1.2 节点的创建

    1.3 节点的链接

    二、树的深度遍历

    1. 前序、中序、后序遍历

    1.2 三种方式的遍历顺序图

    2. 代码实现

    3. 遍历检测

    三、树的层序遍历

    3.1 层序遍历

    3.2 完全二叉树的鉴定

    四、树的基本功能

    4.1 树中节点的个数

    4.2 树中叶子节点的数量

    4.3 第k层节点的数量

    4.4 查找树的节点

    4.5 树的深度

    4.6 树的销毁

    本篇博客学习的是最普通的链式二叉树，这个结构在实际应用的中的作用并不是很大，但是我们仍要学习这个结构。学习这个结构的目的是为了以后我们研究更复杂的树型结构打下基础。废话不多说，直接开始。

    目录

    一、链式二叉树的创建

    1.1 定义节点结构

    1.2 节点的创建

    1.3 节点的链接

    二、树的深度遍历

    2.1 前序、中序、后序遍历

    2.1.1 三种方式的遍历顺序图

    2.1.2 代码实现

    2.1.3 遍历检测

    三、树的基本功能

    3.1 树中节点的个数

    3.2 树中叶子节点的数量

    3.3 第k层节点的数量

    3.4 查找树的节点

    3.5 树的深度

    3.6 树的销毁

    四、树的层序遍历

    4.1 层序遍历

    4.2 完全二叉树的鉴定

    一、链式二叉树的创建

    首先我们来创建一颗树，创建一棵树分为以下三个步骤：①定义树中结点的结构②创建新结点③将结点链接起来；这样就可以一个树就被建立了起来。

    1.1 定义节点结构

    1. //节点的创建
    2. typedef int BTDataType;
    3. typedef struct BinaryTreeNode
    4. {
    5. 	struct BinaryTreeNode* left;
    6. 	struct BinaryTreeNode* right;
    7. 	BTDataType data;
    8. }BTNode;

    1.2 节点的创建

    1. BTNode* BuyNode(BTDataType x)
    2. {
    3. 	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    4. 	assert(node);
    5. 	node->data = x;
    6. 	node->left = NULL;
    7. 	node->right = NULL;
    8. 	return node;
    9. }

    1.3 节点的链接

    1. BTNode* CreatBinaryTree()
    2. {
    3. 	BTNode* node1 = BuyNode(1);
    4. 	BTNode* node2 = BuyNode(2);
    5. 	BTNode* node3 = BuyNode(3);
    6. 	BTNode* node4 = BuyNode(4);
    7. 	BTNode* node5 = BuyNode(5);
    8. 	BTNode* node6 = BuyNode(6);
    9. 	//链接
    10. 	node1->left = node2; //         1 
    11. 	node1->right = node4;//     2       4
    12. 	node2->left = node3;//   3   #    5    6
    13. 	node4->left = node5;// # #       # #  # #
    14. 	node4->right = node6;
    15. 	return node1;
    16. }

    二、树的深度遍历

    树我们是创建好了，接下来我们来观察一下我们树的链接情况，此时就要遍历一遍树。但是树的结构特殊，不同于我们之前学的数组，遍历起来很方便。于是引申出以下几种遍历方式。

    1. 前序、中序、后序遍历

    三种方式的访问顺序

    前序——( 根 --> 左子树 --> 右子树)

    中序——( 左子树 --> 根 --> 右子树)

    后序——( 左子树 --> 右子树 --> 根)

    1.2 三种方式的遍历顺序图

     

     

    2. 代码实现

    这遍历规律性强，我们使用递归可以很容易的写出来，并将每个为NULL的位置打印一个#作为代替。

    前序遍历

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

    中序遍历

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

    后序遍历

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

    3. 遍历检测

    三、树的层序遍历

    完成了以上三种深度遍历后，肯定有人想问了，如果我像按照一层一层的顺序来遍历怎么实现呢？

    层序遍历的实现需要在队列的辅助下才能实现，具体怎么实现我们往下看。

    3.1 层序遍历

    思想：

    ①将根结点放入队列中。

    ②弹出队头元素并打印，然后将队头元素的左结点和右节点依次放入队列

    ③重复以上操作直到队列为空,即可一层一层地遍历完整个树。

            因为，如果左子树或右子树为空，就不会往队列里放了，这样前面的结点会按照前进先出的规律依次出队列，既可达到我们层序遍历的目的。

    1. //层序遍历
    2.  //思想  放一个根节点  弹出一个根节点 连着存放左节点和右节点，
    3.  //队列为空的时候为空就不放了
    4. void LevelOrder (BTNode* root)
    5. {
    6. 	Queue q;
    7. 	QueueInit(&q);
    8. 	if (root)
    9. 	{
    10. 		QueuePush(&q, root);
    11. 	}
    12.  //队列不为空就继续以上操作
    13. 	while (!QueueEmpty(&q))
    14. 	{
    15. 		//出对头的数据
    16. 		BTNode* front = QueueFront(&q);
    17. 		printf("%d ", front->data);
    18. 		QueuePop(&q);
    19. 		if (front->left)
    20. 		{
    21. 			QueuePush(&q, front->left);
    22. 		}
    23. 		if (front->right)
    24. 		{
    25. 			QueuePush(&q, front->right);
    26. 		}
    27. 	}
    28. 	QueueDestroy (&q);
    29. }

    3.2 完全二叉树的鉴定

    完全二叉树：n-1层为满，最后一层不满，而满二叉树是一种特别的完全二叉树。

    思想：

    ①根据层序遍历的规则，依次将根结点、左子树、右子树放入队列

    ②如果对头数据为NULL，则停止插入队列。

    ③对该队列进行检查，如果NULL的后面有非NULL结点，则表示该树不是完全二叉树，直到队列为空(即完全二叉树最后一个结点过后全为NULL结点)。

    先看这个GIF图，然后可以结合代码看理解。

    1. //判断当前树是否是完全二叉树
    2.  //如果空后面还有非空，就不是完全二叉树
    3. bool TreeComplete(BTNode* root)
    4. {
    5. 	Queue q;
    6. 	QueueInit(&q);
    7. 	if (root)
    8. 	{
    9. 		QueuePush(&q, root);
    10. 	}
    11. 	while (!QueueEmpty(&q))
    12. 	{
    13. 		BTNode* front = QueueFront(&q);
    14. 		QueuePop(&q);
    15. 		if (front)
    16. 		{
    17. 			QueuePush(&q, front->left);
    18. 			QueuePush(&q, front->right);
    19. 		}
    20. 		else
    21. 		{
    22. 			//遇到空则跳出层序遍历
    23. 			break;
    24. 		}
    25. 		//1.如果后面全是完全二叉树
    26. 		//2.如果空后面还有非空，则不是完全二叉树
    27. 		while (!QueueEmpty(&q))
    28. 		{
    29. 			BTNode* front = QueueFront(&q);
    30. 			QueuePop(&q);
    31. 			if (front)
    32. 			{
    33. 				return false;
    34. 			}
    35. 		}
    36. 	}
    37. 	QueueDestroy(&q);
    38. 	return true;
    39. }

    四、树的基本功能

    实现了树的遍历还远远不够，我们这里来实现一下更常见的功能。

    4.1 树中节点的个数

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

    4.2 树中叶子节点的数量

    1. //求叶子节点的数量的两种写法  
    2. int TreeLeafSize1(BTNode* root)
    3. {
    4. 	if (root == NULL)
    5. 		return 0;
    6. 	return ((root->left == NULL) && (root->right == NULL)) ? 1 :
    7. 		TreeLeafSize1(root->left) + TreeLeafSize1(root->right) ;
    8. }

    4.3 第k层节点的数量

    1. //求第k层节点的数量
    2. //1.转化为求左子树的k-1层，右子树的k-1层
    3. int KLeveSize(BTNode* root, int k)
    4. {
    5. 	if (root == NULL)
    6. 		return 0;
    7. 	if (k == 1)
    8. 	{
    9. 		return 1;
    10. 	}
    11. 	return KLeveSize(root->left, k - 1) + KLeveSize(root->right, k - 1);
    12. }

    4.4 查找树的节点

    1. //查找树的节点
    2. BTNode* TreeFind(BTNode* root, BTDataType x)
    3. {
    4. 	if (root == NULL)
    5. 		return NULL;
    6. 	if (root->data == x)
    7. 		return root;
    8. 	/*if (TreeFind(root->left, x) )
    9. 		return TreeFind(root->left, x);
    10. 	if (TreeFind(root->right, x))
    11. 		return TreeFind(root->right, x);*/
    12. 	
    13. 	//以上方法会深部遍历两次  不推荐
    14. 	BTNode* LeftNode = TreeFind(root->left, x);
    15. 	if (LeftNode)
    16. 		return LeftNode;
    17. 	BTNode* RightNode = TreeFind(root->right, x);
    18. 	if (RightNode)
    19. 		return RightNode;
    20. 	return NULL;
    21. }

    4.5 树的深度

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

    4.6 树的销毁

    1. //二叉树的销毁
    2. //后序遍历销毁
    3. void TreeDestory(BTNode* root)
    4. {
    5. 	if (root == NULL)
    6. 		return;
    7. 	TreeDestory(root->left);
    8. 	TreeDestory(root->right);
    9. 	//本不应在  检查使用
    10. 	//free之前打印一下释放的情况
    11. 	printf("\n%p :  %d ", root,root->data);
    12. 	free(root);
    13. }

    二叉树相对于前面的栈和队列难度有所提升，要对递归比较熟悉，大家可以结合画图慢慢消化。递归类的代码不好调试，大家可以结合深度遍历以打印的方式来观察，或者在电脑画图板上走读代码理解。

    本篇博客到此就结束了，二叉树还是很有难度的，接下来会做一些练习然后开始学习堆，希望大家持续关注。

  • 相关阅读:
    Windows平台上安装MySql 5.6 /8.0等的各种问题解决办法汇总
    【C++ 科学计算】线性代数和科学计算库 Armadillo 构建安装
    学习笔记-Nginx
    【英语：王者进阶_高级别学术阅读】K1.快速摸清段落主题
    红队隧道应用篇之Frp内网穿透（十）
    Spring cloud stream binder kafka 常用配置
    从同步函数 hello-world-dotnet 开始探索OpenFunction
    PHP NBA球迷俱乐部系统Dreamweaver开发mysql数据库web结构php编程计算机网页
    相控阵天线（八）：圆环阵列天线和球面阵列天线
    【gmoj】旅行
  • 原文地址：https://blog.csdn.net/Brant_zero/article/details/125581620