文章目录
- 前言
- 一、链式二叉树的结构
- 二、链式二叉树的创建
- 三、二叉树的遍历
-
- [3.1 前序遍历](#3.1 前序遍历)
- [3.2 中序遍历](#3.2 中序遍历)
- [3.3 后序遍历](#3.3 后序遍历)
- 四、链式二叉树的基本操作
-
- [4.1 统计二叉树结点个数](#4.1 统计二叉树结点个数)
- [4.2 统计叶子结点个数](#4.2 统计叶子结点个数)
- [4.3 统计第 k 层结点个数](#4.3 统计第 k 层结点个数)
- [4.4 计算二叉树的高度](#4.4 计算二叉树的高度)
- [4.5 查找指定结点](#4.5 查找指定结点)
- [4.6 二叉树的销毁](#4.6 二叉树的销毁)
- 五、二叉树的层序遍历
-
- [5.1 队列的使用](#5.1 队列的使用)
- [5.2 层序遍历的实现](#5.2 层序遍历的实现)
- 六、判断二叉树是否为完全二叉树
- 七、总结
前言
二叉树是数据结构中非常重要的一部分,而链式结构又是实现二叉树最常见的方式。相比顺序存储,链式二叉树通过指针把一个个结点连接起来,结构更灵活,也更贴近二叉树本身的递归定义。
本文从链式二叉树的结构定义讲起,依次介绍二叉树的创建、三种递归遍历(前序、中序、后序)、常见基本操作(统计结点、叶子结点、第 k 层结点、树高、查找、销毁),最后再讲层序遍历以及如何判断一棵二叉树是否为完全二叉树。
文中所有代码均使用 C 语言实现,示例完整、可直接编译运行。阅读本文前,建议先了解指针、结构体、动态内存分配以及递归的基本用法,这样理解起来会更顺畅。
一、链式二叉树的结构
链式二叉树使用链表来存储结点之间的关系。与顺序结构不同,链式结构不需要提前分配连续的存储空间,而是通过指针将各个结点连接起来。
一个二叉树结点通常由三个部分组成:
- 数据域:存储结点的数据。
- 左指针:指向当前结点的左孩子。
- 右指针:指向当前结点的右孩子。
因此,可以使用下面的结构体定义二叉树结点:
c
typedef int BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left; // 指向左孩子
struct BinaryTreeNode* right; // 指向右孩子
BTDataType val; // 结点数据
} BTNode;
其中,left 和 right 分别指向当前结点的左右孩子。如果某个孩子不存在,对应的指针就为 NULL。
二、链式二叉树的创建
二叉树的创建相对复杂,因为每个结点都需要动态申请空间,并通过指针建立结点之间的关系。
为了方便理解,我们先通过手动创建的方式构建一棵二叉树。
首先,定义一个创建新结点的函数:
c
BTNode* BuyBTNode(BTDataType val)
{
BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
if (newnode == NULL)
{
perror("malloc fail");
return NULL;
}
newnode->val = val;
newnode->left = NULL;
newnode->right = NULL;
return newnode;
}
这个函数通过 malloc 动态申请一个结点的空间,然后初始化数据域和左右指针,最后返回新结点的地址。
有了创建结点的函数,就可以通过修改左右指针,将各个结点连接起来。
c
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);
n1->left = n2;
n1->right = n4;
n2->left = n3;
n4->left = n5;
n4->right = n6;
return n1;
}
最终创建的二叉树如下:
text
1
/ \
2 4
/ / \
3 5 6
这里的 n1 就是整棵二叉树的根结点,通过返回 n1,就可以访问整棵二叉树。
可以发现,链式二叉树的结点之间并不要求连续存储,只需要通过左右指针建立正确的关系即可。
三、二叉树的遍历
二叉树的很多操作都需要访问树中的结点,因此,遍历是链式二叉树中非常重要的基本操作。
根据访问根结点的时机不同,二叉树的递归遍历主要分为三种:
- 前序遍历
- 中序遍历
- 后序遍历
这三种遍历方式的区别在于根结点、左子树和右子树的访问顺序。
3.1 前序遍历
前序遍历(Preorder Traversal),也称先序遍历。
访问顺序为:
根结点 → 左子树 → 右子树
代码实现:
c
void PreOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
printf("%d ", root->val);
PreOrder(root->left);
PreOrder(root->right);
}
这段代码比较好理解:先访问当前结点,然后递归遍历左子树,最后递归遍历右子树。如果当前结点为空,就直接返回。
以之前创建的二叉树为例,按照根、左、右的顺序访问,得到:
前序遍历结果:1 2 3 4 5 6
3.2 中序遍历
中序遍历(Inorder Traversal)。
访问顺序为:
左子树 → 根结点 → 右子树
代码实现:
c
void InOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
InOrder(root->left);
printf("%d ", root->val);
InOrder(root->right);
}
与前序遍历相比,这里的区别只是把访问根结点的操作放到了两个递归调用之间。
也就是说,先遍历完左子树,再访问当前结点,最后遍历右子树。
中序遍历结果:3 2 1 5 4 6
3.3 后序遍历
后序遍历(Postorder Traversal)。
访问顺序为:
左子树 → 右子树 → 根结点
代码实现:
c
void PostOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->val);
}
这次将访问根结点的操作放到了最后,先遍历左子树和右子树,最后才访问当前结点。
后序遍历结果:3 2 5 6 4 1
可以发现,三种遍历方式的代码结构几乎一样,主要区别就是 printf 的位置。理解这一点,就能比较容易地掌握二叉树的递归遍历。
四、链式二叉树的基本操作
利用二叉树的递归结构,可以实现很多基本操作,例如统计结点个数、统计叶子结点个数、计算二叉树高度以及查找指定结点等。
常见的操作接口如下:
c
// 二叉树结点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第 k 层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树的深度/高度
int BinaryTreeDepth(BTNode* root);
// 二叉树查找值为 x 的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树销毁
void BinaryTreeDestroy(BTNode** root);
4.1 统计二叉树结点个数
一棵二叉树的结点总数,等于根结点、左子树结点和右子树结点的数量之和。
c
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)
{
return 0;
}
return 1 + BinaryTreeSize(root->left)
+ BinaryTreeSize(root->right);
}
当结点为空时,返回 0;否则将当前结点计为 1,再分别统计左右子树的结点个数,最后相加即可。
4.2 统计叶子结点个数
叶子结点是指没有孩子结点的结点,也就是左右指针都为 NULL 的结点。
c
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL)
{
return 0;
}
if (root->left == NULL && root->right == NULL)
{
return 1;
}
return BinaryTreeLeafSize(root->left)
+ BinaryTreeLeafSize(root->right);
}
如果当前结点为空,就返回 0;如果左右孩子都为空,说明找到了一个叶子结点,返回 1。其他情况下,继续统计左右子树中的叶子结点数量。
4.3 统计第 k 层结点个数
统计二叉树第 k 层的结点个数,可以利用递归逐层向下查找。
c
int BinaryTreeLevelKSize(BTNode* root, int k)
{
if (root == NULL || k < 1)
{
return 0;
}
if (k == 1)
{
return 1;
}
return BinaryTreeLevelKSize(root->left, k - 1)
+ BinaryTreeLevelKSize(root->right, k - 1);
}
当 k == 1 时,说明当前结点就是需要统计的这一层,返回 1。
否则,分别统计左右子树的第 k-1 层结点数量,再将结果相加。
4.4 计算二叉树的高度
二叉树的高度,也称深度,表示从根结点到最远叶子结点的层数。
计算高度时,可以分别求出左子树和右子树的高度,再取其中较大的一个加 1。
c
int BinaryTreeDepth(BTNode* root)
{
if (root == NULL)
{
return 0;
}
int leftDepth = BinaryTreeDepth(root->left);
int rightDepth = BinaryTreeDepth(root->right);
return leftDepth > rightDepth
? leftDepth + 1
: rightDepth + 1;
}
空树的高度为 0,只有根结点的二叉树高度为 1。
4.5 查找指定结点
查找值为 x 的结点,可以按照根结点、左子树、右子树的顺序进行递归查找。
c
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
{
return NULL;
}
if (root->val == x)
{
return root;
}
BTNode* ret = BinaryTreeFind(root->left, x);
if (ret != NULL)
{
return ret;
}
return BinaryTreeFind(root->right, x);
}
先判断当前结点是否就是要找的结点,如果不是,就去左子树中查找。如果左子树中找到了,就直接返回结果;否则再去右子树中查找。
如果整棵二叉树都没有找到,就返回 NULL。
4.6 二叉树的销毁
二叉树使用动态内存申请结点,因此在不再使用时,需要释放每个结点所占用的空间。
销毁二叉树时,应该先销毁左右子树,最后释放当前结点。
c
void BinaryTreeDestroy(BTNode** root)
{
if (root == NULL || *root == NULL)
{
return;
}
BinaryTreeDestroy(&(*root)->left);
BinaryTreeDestroy(&(*root)->right);
free(*root);
*root = NULL;
}
这里使用的是二级指针,因为函数不仅需要释放结点,还需要将外部保存的根指针置为 NULL,避免出现野指针。
五、二叉树的层序遍历
除了前序、中序和后序遍历,还可以按照结点所在的层次进行访问,这种方式称为层序遍历(Level Order Traversal)。
层序遍历的规则是:
从根结点开始,先访问第一层,再从左到右访问第二层,接着访问第三层,以此类推,按照从上到下、从左到右的顺序逐层访问所有结点。
例如:
text
1
/ \
2 3
/ \ \
4 5 6
/
7
层序遍历结果为:
1 2 3 4 5 6 7
5.1 队列的使用
实现层序遍历需要借助队列。
队列具有先进先出的特点,刚好符合层序遍历的访问顺序:先进入队列的结点先被访问,而它的左右孩子再依次进入队列。
这里使用的队列与之前实现的普通队列类似,不过需要注意,队列中存储的不是普通整数,而是二叉树结点的指针 BTNode*。
例如,队列需要提供以下基本接口:
c
typedef BTNode* QDataType;
// 队列初始化
void QueueInit(Queue* pq);
// 入队
void QueuePush(Queue* pq, QDataType x);
// 获取队头元素
QDataType QueueFront(Queue* pq);
// 出队
void QueuePop(Queue* pq);
// 判断队列是否为空
bool QueueEmpty(Queue* pq);
// 队列销毁
void QueueDestroy(Queue* pq);
以上只是层序遍历需要用到的队列接口,队列的具体链表实现不在这里展开。实际使用时,需要提前准备好对应的队列结构和函数实现。
5.2 层序遍历的实现
具体过程:
- 将根结点入队。
- 取出队头结点并访问。
- 如果该结点存在左孩子,将左孩子入队。
- 如果该结点存在右孩子,将右孩子入队。
- 重复上述过程,直到队列为空。
代码实现:
c
void LevelOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
Queue q;
QueueInit(&q);
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
printf("%d ", front->val);
if (front->left)
{
QueuePush(&q, front->left);
}
if (front->right)
{
QueuePush(&q, front->right);
}
}
QueueDestroy(&q);
}
每次取出队头结点时,先访问它,再将它的左右孩子依次入队。这样就能保证结点按照从上到下、从左到右的顺序被访问。
六、判断二叉树是否为完全二叉树
完全二叉树是指:除最后一层外,其余各层都达到最大结点数,并且最后一层的结点都连续集中在最左边。
判断一棵二叉树是否为完全二叉树,可以利用层序遍历的思想。
具体思路:
- 将根结点入队。
- 进行层序遍历,遇到空结点时,说明已经到达了结点排列的末尾部分。
- 从第一次遇到空结点开始,如果后面还出现非空结点,则说明这棵二叉树不是完全二叉树。
- 如果后面全部为空结点,则说明它是完全二叉树。
代码实现:
c
bool BinaryTreeComplete(BTNode* root)
{
if (root == NULL)
{
return true;
}
Queue q;
QueueInit(&q);
QueuePush(&q, root);
bool meetNull = false;
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front == NULL)
{
meetNull = true;
}
else
{
if (meetNull)
{
QueueDestroy(&q);
return false;
}
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
}
QueueDestroy(&q);
return true;
}
这里有一个需要注意的地方:判断完全二叉树时,即使结点的左右孩子为空,也需要将 NULL 入队。这样才能通过层序遍历判断空结点之后是否还存在非空结点。
因此,这里使用的队列必须允许存储 NULL 指针,不能在入队时直接忽略空指针。
七、总结
链式二叉树的很多操作都可以利用递归实现,这是因为二叉树本身就是一种递归定义的数据结构。
前序、中序、后序遍历的区别在于访问根结点的时机,而统计结点个数、计算树的高度等操作,也都是将整棵树拆分成左右子树,再分别处理。
另外,层序遍历和判断完全二叉树则需要借助队列完成。
理解二叉树的递归结构,以及队列在层序遍历中的作用,是掌握链式二叉树基本操作的关键。