【数据结构初阶】链式二叉树接口实现超详解

文章目录

1. 节点定义
2. 前中后序遍历
- 2. 1 遍历规则
- 2. 2 遍历实现
- 2. 3 结点个数
- - 2. 3. 1 二叉树节点个数
  - 2. 3. 2 二叉树叶子节点个数
  - 2. 3. 3 二叉树第k层节点个数
- 2. 4 二叉树查找值为x的节点
- 2. 5 二叉树层序遍历
- 2. 6 判断二叉树是否是完全二叉树
3. 二叉树性质

1. 节点定义

用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址，其基本结构如下：

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;				//数据
	struct BinaryTreeNode* left;	//左孩子
	struct BinaryTreeNode* right;	//右孩子
}BTNode;

链式二叉树的创建方式比较复杂，为了更好地对接口进行调试，我们先手动创建一棵链式二叉树进行测试：

//创建节点
BTNode* BuyBTNode(int val)
{
	BTNode * newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = val;
	newnode->left = NULL;
	newnode->right = NULL;
	return newnode;
}
BTNode * CreateTree()
{
	BTNode * n1 = BuyBTNode(1);
	BTNode * n2 = BuyBTNode(2);
	BTNode * n3 = BuyBTNode(3);
	BTNode * n4 = BuyBTNode(4);
	BTNode * n5 = BuyBTNode(5);
	BTNode * n6 = BuyBTNode(6);
	BTNode * n7 = BuyBTNode(7);
	//手动将他们连接起来成为一棵二叉树
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n4->left = n5;
	n4->right = n6;
	n5->left = n7;
	
	return n1;
}

接下来就可以用这棵二叉树对接口进行测试。

2. 前中后序遍历

二叉树不同于之前的顺序结构，不能直接进行依次遍历，必须按照一定的规则进行遍历。
注：堆也是一种二叉树，但是堆不能进行遍历，所以没有这方面的考虑。
另外二叉树的链式结构是一个递归的结构，几乎所有的接口实现都需要用到递归的思想。

2. 1 遍历规则

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

前序遍历(Preorder Traversal，亦称先序遍历)：访问根结点的操作发生在遍历其左右子树之前
访问顺序为：根结点、左子树、右子树
中序遍历(lnorder Traversal)：访问根结点的操作发生在遍历其左右子树中间
访问顺序为：左子树、根结点、右子树
后序遍历(Postorder Traversal)：访问根结点的操作发生在遍历其左右子树之后
访问顺序为：左子树、右子树、根结点

我们以前序遍历解释一下怎么遍历：

从根节点1开始遍历，先输出根节点数据1，然后来到左孩子2，输出2，来到2的左孩子3，输出3，来到3的左孩子NULL，回退至3，来到3的右孩子NULL，再回退，3节点遍历完毕，回退至2，来到2的右节点NULL，回退至2,2节点遍历完毕，回退至1，来到1的右孩子4，先输出4，再来到4的左孩子4，输出4，遍历左右俩孩子都为空，回退至上面的4，来到4的右孩子5，输出5后，俩孩子都为空，再最终回退至1，根节点遍历完成，该二叉树遍历完成。
前序遍历结果：123456
中序遍历结果：321546
后序遍历结果：315641

2. 2 遍历实现

在实现时，我们可以把每一个孩子都看成一个二叉树的根节点，以方便递归遍历。

//前序遍历
void BinaryTreePrevOrder(BTNode* root)
{
	if (!root)
		return;
	printf("%d ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}
//后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (!root)
		return;
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
	printf("%d ", root->data);
}
//中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (!root)
		return;
	BinaryTreePrevOrder(root->left);
	printf("%d ", root->data);
	BinaryTreePrevOrder(root->right);
}

2. 3 结点个数

2. 3. 1 二叉树节点个数

int BinaryTreeSize(BTNode* root);

二叉树中只有结点，没有把数据个数存储起来，那么我们要怎么获取二叉树中元素的个数呢？
有两种思路，一个是创建全局变量，然后通过任意一种遍历方式遍历二叉树，每遍历一次都让这个变量++，那么就能得到节点的个数了，但是这样会带来两个问题：

全局变量每次都要归0，但是由于是递归进行遍历的，所以需要写一个子函数用于递归。
在函数内部调用全部变量可能会存在危险，因为这个变量是任何函数都能访问并修改的。

基于这样的原因，我们不采用这个方式。
而是通过计算这个节点本身+左子树节点的个数+右子树节点的个数的方式进行递归。

int BinaryTreeSize(BTNode* root)
{
	if (!root)
		return 0;
	return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);	//1就是该节点本身，再加上左右两棵子树
}

2. 3. 2 二叉树叶子节点个数

int BinaryTreeLeafSize(BTNode* root);

叶子节点的特点就是root->left == NULL && root->right == NULL，所以只要加上一个判断是否要+1，其他的就和计算节点个数的思路是一样的。

int BinaryTreeLeafSize(BTNode* root)
{
	//如果是叶子节点，就没必要继续向下传递了，直接回归就可以了
	if (!root)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

2. 3. 3 二叉树第k层节点个数

int BinaryTreeLevelKSize(BTNode* root, int k);

在传递时增加一个参数k，来判断递归到哪一层了，如果是目标层数，就+1回归，其他与计算二叉树叶子节点个数思路一致。

int BinaryTreeLevelKSize(BTNode* root, int k)
{
	//同理，到目标层数之后就不需要继续向下传递了
	if (!root)
		return 0;
	if (k == 1)
		return 1;
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

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

BTNode* BinaryTreeFind(BTNode* root, BTDataType x);

在二叉树中遍历并对比数据，如果找到了就返回这个节点的指针，没找到就返回NULL。

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (!root)
		return NULL;
	if (root->data == x)
		return root;
	//需要分别判断左右子树中有没有这个数据
	//左
	BTNode* leftfind = BinaryTreeFind(root->left,x);
	if (leftfind)
		return leftfind;
	//右
	BTNode* rightfind = BinaryTreeFind(root->right,x);
	if (rightfind)
		return rightfind;
	//没找到，返回空
	return NULL;
}

2. 5 二叉树层序遍历

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

层序遍历就是一层一层地从左到右地进行遍历，比如上面这棵二叉树的层序遍历就是：1 2 3 4 5 6 7

大致思路为：创建一个数据类型为BTNode*的队列，先将根节点入队列，然后分别将它的左右孩子入队列，接着出队列一次。然后把队头的左右孩子（如果不为NULL）入队列，再出队列一次，每次出队列前都要把它的值打印出来，循环以上过程直到队列为空。

注：这里的队列不再实现，可以看这篇博客。

void BinaryTreeLevelOrder(BTNode* root)
{
	//二叉树判空
	if (!root)
		printf("null\n");
	//创建队列并初始化
	Queue qu;
	QueueInit(&qu);
	//把根节点入队列
	QueuePush(&qu,  root);
	while (!QueueEmpty(&qu))
	{
		//将队头的左右子树入队列，并将队头数据打印，再出队列一次
		BTNode* tmp = QueueFront(&qu);
		QueuePop(&qu);
		printf("%d ", tmp->data);
		if (tmp->left)
			QueuePush(&qu, tmp->left);
		if (tmp->right)
			QueuePush(&qu, tmp->right);
	}
	//销毁队列
	QueueDestroy(&qu);
	printf("\n");
}

2. 6 判断二叉树是否是完全二叉树

bool BinaryTreeComplete(BTNode* root);

完全二叉树的特点是第X层没有完全放满时，X+1层不能有节点，且没有满的层的节点必须是从左往右排布的。

我们可以借助层序遍历来判断二叉树是不是完全二叉树。
步骤为：就算节点为空也要入队列，直到出队列时遇到了空节点时，开始连续出队列，如果队列中剩下的元素中有非空的节点，就说明不是完全二叉树。

我们以这棵二叉树为例：

当轮到4的左孩子（尽管不存在，但先这么理解一下）出队列时，开始不再入队列，只出队列并判断是否为空，这时队列中还有4的右节点7，那就判断出来了二叉树不是完全二叉树。

如果在第一次出队列的为空节点的之后的节点都是空节点（比如上面这个二叉树没有节点7），那就是完全二叉树。

bool BinaryTreeComplete(BTNode* root)
{
	assert(root);
	Queue qu;
	QueueInit(&qu);
	QueuePush(&qu, root);
	while (!QueueEmpty(&qu))
	{
		BTNode* tmp = QueueFront(&qu);
		//如果出队列的是空节点，就停止这个循环
		if (!tmp)
			break;
		QueuePop(&qu);
		QueuePush(&qu, tmp->left);
		QueuePush(&qu, tmp->right);
	}
	//这个循环只出不入
	while (!QueueEmpty(&qu))
	{
		//如果队列中还有空节点，就说明不是完全二叉树
		if (QueueFront(&qu))
		{
			QueueDestroy(&qu);
			return false;
		}
		QueuePop(&qu);
	}
	QueueDestroy(&qu);
	return true;
}

3. 二叉树性质

对任何一棵二叉树,如果度为 0 的叶结点个数为n₀，度为 2 的分支结点个数为n₂ ，则有
n₀ = n₂+1

证明：
假设一个二叉树有 a 个度为 2 的节点，b 个度为 1 的节点，c 个叶节点，则这个二叉树的边数是 2a+b
另一方面，由于共有 a+b+c 个节点，所以边数等于 a+b+c-1
结合上面两个公式:
即 2a+b = a+b+c-1，即 a=c-1

题目练习

某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）
A 不存在这样的二叉树
B 200
C 198
D 199
有199个度为2的节点，那么在二叉树中，度为0的节点有199+1也就是200个，选B。
在具有 2n 个结点的完全二叉树中，叶子结点个数为()
A n
B n+1
C n-1
D n/2
设叶子节点有x个，那么度为2的节点为x-1个。有2n个节点，所以度为1的节点有2n-2x+1条，而完全二叉树中度为1的节点只有0或1个，但是这个二叉树的结点个数为偶数（由于根节点有1个，而其他的除了最后一层的结点个数都是偶数），所以度为1的结点个数为1。解方程2n-2x+1=1就可以得出x=n。选A。
一棵完全二叉树的结点数位为531个，那么这棵树的高度为()
A 11
B 10
C 8
D 12
完全二叉树每一层的节点个数为2^n-1个，那么根据等比数列的求和公式，完全二叉树前n层的节点个数为2ⁿ-1，解方程2ⁿ-1>=531可得，n为10，选B。
一个具有767个结点的完全二叉树，其叶子结点个数为()
A 383
B 384
C 385
D 386
设叶子节点有x个，那么度为2的节点为x-1个，度为1的节点为768-2x个，通过第2题的分析我们可知度为1的节点为0个，就可以算出x=384，选B。