链式二叉树的实现与基本操作

文章目录

前言

二叉树是数据结构中非常重要的一部分,而链式结构又是实现二叉树最常见的方式。相比顺序存储,链式二叉树通过指针把一个个结点连接起来,结构更灵活,也更贴近二叉树本身的递归定义。

本文从链式二叉树的结构定义讲起,依次介绍二叉树的创建、三种递归遍历(前序、中序、后序)、常见基本操作(统计结点、叶子结点、第 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 层序遍历的实现

具体过程:

  1. 将根结点入队。
  2. 取出队头结点并访问。
  3. 如果该结点存在左孩子,将左孩子入队。
  4. 如果该结点存在右孩子,将右孩子入队。
  5. 重复上述过程,直到队列为空。

代码实现:

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);
}

每次取出队头结点时,先访问它,再将它的左右孩子依次入队。这样就能保证结点按照从上到下、从左到右的顺序被访问。

六、判断二叉树是否为完全二叉树

完全二叉树是指:除最后一层外,其余各层都达到最大结点数,并且最后一层的结点都连续集中在最左边。

判断一棵二叉树是否为完全二叉树,可以利用层序遍历的思想。

具体思路:

  1. 将根结点入队。
  2. 进行层序遍历,遇到空结点时,说明已经到达了结点排列的末尾部分。
  3. 从第一次遇到空结点开始,如果后面还出现非空结点,则说明这棵二叉树不是完全二叉树。
  4. 如果后面全部为空结点,则说明它是完全二叉树。

代码实现:

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 指针,不能在入队时直接忽略空指针。


七、总结

链式二叉树的很多操作都可以利用递归实现,这是因为二叉树本身就是一种递归定义的数据结构。

前序、中序、后序遍历的区别在于访问根结点的时机,而统计结点个数、计算树的高度等操作,也都是将整棵树拆分成左右子树,再分别处理。

另外,层序遍历和判断完全二叉树则需要借助队列完成。

理解二叉树的递归结构,以及队列在层序遍历中的作用,是掌握链式二叉树基本操作的关键。

相关推荐
艾莉丝努力练剑44 分钟前
【QT】系统相关:TCP的API介绍
开发语言·前端·c++·人工智能·qt·学习·tcp/ip
青少儿编程课堂1 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:中国剩余定理解析
c++·python·算法·bfs·信息学竞赛
wo_jack1 小时前
C++ 入门笔记(十八):list 进阶 —— const 迭代器、operator-> 与 clear 的坑
数据结构·c++·面试·stl·list
wuxianda10302 小时前
Swift 项目用 Xcode 脚手架起步:默认工程结构和依赖组合为什么会被识别成同源
开发语言·xcode·swift·4.3a·appstore审核
ShineWinsu2 小时前
对于Qt:QVBoxLayout常见属性以及方法的解析
开发语言·数据库·c++·qt·gui·客户端·布局管理器
Sarvartha2 小时前
反射综合案例:SQL 语句生成
java·开发语言
ShineWinsu13 小时前
对于Qt:QFormLayout常见属性以及方法的解析
开发语言·c++·qt·面试·客户端·表单·qformlayout
罗西的思考14 小时前
【轻量化复刻大模型 / KIMI K3】Muon 优化器及 训练系统
人工智能·算法·机器学习
ashiho15 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口