二叉树（4）——链式二叉树

垂柳斜下茉莉雨

已于 2024-02-18 21:13:11 修改

阅读量782

点赞数 21

分类专栏：数据结构文章标签：数据结构算法

于 2024-02-18 21:11:34 首次发布

本文链接：https://blog.csdn.net/linxiaogua123/article/details/136123339

版权

数据结构专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1 二叉树的概念

二叉树是：

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

二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。

2 二叉树的遍历

2.1 前序、中序以及后序遍历

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

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

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

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

要注意：空NULL才是结束条件，而不是叶子。只有看到NULL了才不往下遍历。

2.2 二叉树链式结构的实现

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

2.2.1 手动构建二叉树

//二叉树节点结构体
typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}TreeNode;

//手动构建一个二叉树
TreeNode* BuyTreeNode(int x)
{
	TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
	assert(node);
    //给出根节点，左右子树记为空
	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

TreeNode* CreateTree()
{
	TreeNode* node1 = BuyTreeNode(1);
	TreeNode* node2 = BuyTreeNode(2);
	TreeNode* node3 = BuyTreeNode(3);
	TreeNode* node4 = BuyTreeNode(4);
	TreeNode* node5 = BuyTreeNode(5);
	TreeNode* node6 = BuyTreeNode(6);
	TreeNode* node7 = BuyTreeNode(7);

    //连接树
	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	node5->right = node7;

	return node1;
}

注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解。

2.2.2 二叉树遍历代码实现

//前序
void PrevOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	printf("%d ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

//中序
void InOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}
 
 
//后序
void PostOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
 
	PostOrder(root->left);//左
	PostOrder(root->right);//右
	printf("%d ", root->data);//根
}
 
int main()
{
	TreeNode* root = CreateTree();
	// 二叉树前序遍历
	PreOrder(node);
	printf("\n");
	// 二叉树中序遍历
    InOrder(node);
	printf("\n");
	// 二叉树后序遍历
    PostOrder(node);
 
}

前序遍历

递归理解：先进入函数，然后递归返回，直到全部返回完毕，函数结束。

中序遍历

2.2.3 计算二叉树节点个数

方法一：遍历

问题解决

下面这样可以吗?

int TreeSize(TreeNode* root)
{
	int size = 0;
	if (root == NULL)
	{
		return 0;
	}

	++size;

	TreeSize(root->left);
	TreeSize(root->right);

	return size;
}

不可以。我们要知道，这样会递归出来很多个栈帧，而每一个栈帧都会创建一个新的size，最后size并没有实现累加。

针对以上问题，我们用静态static int size定义size可以解决问题：不把size放进栈帧，而是放进静态区。

但如果我们再次调用一下函数，会发现size的值变成了14。这是为什么呢？

原因：局部的静态变量只会被初始化一次。静态局部变量生命周期是程序结束，如果我们重复调用TreeSize函数，它会以上一次的结果为初始值进行累加，那么节点个数就会成倍增长。

如果每次用完将size置0呢？

也不可以，因为虽然局部静态变量的生命周期是在全局，但是它的作用域只在当前函数。而在函数里我们并不能找到地方将其置0。

根据以上问题，我们可以用全局变量，每次调用完函数以后将其置0即可。

代码实现

int size = 0;

void TreeSize(TreeNode* root)
{
	if (root == NULL)
	{
		return;
	}

	++size;

	TreeSize(root->left);
	TreeSize(root->right);
}

int main()
{
	TreeNode* root = CreateTree();

	//输出节点个数size的值
	size = 0;
	TreeSize(root);
	printf("TreeSize:%d\n",size);

	size = 0;
	TreeSize(root);
	printf("TreeSize:%d\n", size);

	size = 0;
	TreeSize(root);
	printf("TreeSize:%d\n", size);

	return 0;
}

方法二：递归（首选思路）

代码实现

int TreeSize(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
 
	return TreeSize(root->left) + TreeSize(root->right) + 1;
}

int main()
{
    TreeNode* root = CreateTree();

	printf("TreeSize:%d\n", TreeSize(root));
	printf("TreeSize:%d\n", TreeSize(root));
	printf("TreeSize:%d\n", TreeSize(root));
}

也可以用三目运算符简写如下

int TreeSize(TreeNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) +TreeSize(root->right) + 1;
}

思路分析

可看成校长安排数学校人数问题。

要控制好子问题分治和代码返回条件。

分治：根+左子树的节点个数+右子树的节点个数
返回条件：空树返回0

2.2.4 计算二叉树叶子节点个数

分治：左子树的叶子节点+右子树的叶子节点
返回条件：若为空树返回0，若为叶子节点则返回1。

代码实现

// 叶子节点的个数
int TreeLeafSize(TreeNode* root)
{
	// 空 返回0
	if (root == NULL)
		return 0;
	// 不是空，是叶子 返回1
	if (root->left == NULL
		&& root->right == NULL)
		return 1;

	// 不是空 也不是叶子  分治=左右子树叶子之和
	return TreeLeafSize(root->left) +
		TreeLeafSize(root->right);
}

2.2.5 计算二叉树的高度

分治：左子树和右子树中高的子树+1（每一层都要进行筛选）
返回条件：空树NULL返回0

代码实现

方法一

int TreeHeight(TreeNode* root)
{
	if (root == NULL)
		return 0;
	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

方法二

#include<math.h>

int TreeHeight(TreeNode* root)
{
	if (root == NULL)
		return 0;

	return fmax(TreeHeight(root->left), TreeHeight(root->right)) + 1;
}

注意：以下这种写法，在OJ里可能会过不去，因为如果数很多很多就会调用次数太多，有大量的重复计算，超出时间限制。

int TreeHeight(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return TreeHeight(root->left) > TreeHeight(root->right) ? 
		TreeHeight(root->left) + 1 : 
		TreeHeight(root->right) + 1;
}

下一节我们继续讲解二叉树第K层的节点个数的代码实现。