线索二叉树的建立和遍历（附源码）（前/中/后序）「数据结构算法精讲」

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量2.9k 收藏 16
点赞数 7
文章标签： 算法 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BBBling/article/details/117444965
版权

前言：二叉树的非递归遍历算法（点此学习算法）避免了系统栈的调用，提高了执行效率。而线索二叉树可以将用户栈也省去，把二叉树的遍历过程线性化，进一步提高效率（但代价就是会使用较多的的存储空间）。

完整代码见文章末尾

普通的二叉链表，n个结点的二叉树会有n+1个空链域，为了把这些空链域有效的利用起来，线索二叉树出现了。
线索二叉树的结点构造如下：

lchildltagdatartagrchild
左孩子左标识域数据域右孩子右标识域
typedef struct TBTNode // 定义线索二叉树的节点
{
    char data; // 节点数据类型
    int ltag, rtag; // 线索标记
    struct TBTNode *lchild; // 左孩子
    struct TBTNode *rchild; // 右孩子
}TBTNode;

中序线索化二叉树

由于二叉树的（前序/中序/后序）线索化都极为相似，所以本篇着重讲解中序线索化。

二叉树线索化的过程中，会把树中的空指针利用起来作为寻找当前结点前驱或后继的线索，但这样会出现一个问题，即线索和树中原有的指向孩子结点的指针无法区分。所以在线索二叉树的结构中额外添加了 ltag 和 rtag 两个标识域，用来区分他们的孩子是否存在，具体含义如下：

  1. 如果 ltag=0，表示 lchild 为指针，指向结点的左孩子；如果 ltag=1，表示 lchild 为线索，指向结点的直接前驱。
  2. 如果 rtag=0，表示 rchild 为指针，指向结点的右孩子；如果 rtag=1，表示 rchild 为线索，指向结点的直接后继。

分析：使用二叉树中序递归算法框架，在遍历过程中连接上合适的线索即可

规则：

  1. 在某一时刻 p 指针指向当前正在访问的结点，pre指向 p 的前驱结点；
  2. p 的左线索如果存在，则让其指向 pre；
  3. pre 的右线索如果存在则让其指向 p，因为 p 是 pre 的后继结点；
  4. 当 p 将要离开一个访问过的结点的时候，pre 指向 p，当 p 来到一个新的结点时，pre 显然指向的是此时 p 所指结点的前驱结点。

例子：
在这里插入图片描述

  1. 如图所示，某一时刻 p 指向 A，pre 指向了中序遍历过程中 A 的前驱结点 D
  2. A 是 D 的后继，D 的右线索存在则指向 A

……当整颗二叉树遍历完的时候，线索化也就完成了。代码如下：

void InThread(TBTNode *p, TBTNode *&pre)
{
    if(p != NULL)
    {
        InThread(p->lchild, pre); // 递归，左子树线索化
        if(p->lchild == NULL)
        {
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL) // pre != NULL 排除第一个结点前驱为空的情况
        {
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
        p = p->rchild;
        InThread(p, pre); // 递归，右子树线索化
    }
}

void createInThread(TBTNode *root)
{
    TBTNode *pre = NULL;
    if(root != NULL)
    {
        InThread(root, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}

中序遍历线索二叉树

因为二叉树已经被中序线索化，所以我们遍历链表，并按照中序（左->根->右）的方式访问结点即可。

  1. 优先访问根左子树，找到第一个访问的结点，也就位于树最左下的结点（不一定是叶子结点）；
  2. 找到结点，若当前结点存在右子树，优先访问右子树的左子树（中序遍历的要求）；
  3. 若当前结点不存在右子树，直接访问当前结点的后继结点（线索化时添加的后继线索）；
  4. 重复2、3。

由此可见，第一个访问的结点，和后序访问的其他结点的访问方式有所不同，所以需要将逻辑分开，容易得到代码：

TBTNode *First(TBTNode *p) // 中序序列下第一个结点访问算法
{
    while (p->ltag == 0)
        p = p->lchild; // 最左下结点（不一定是叶子结点）
    return p;
}

TBTNode *Next(TBTNode *p) // 中序序列下后继结点访问算法
{
    if(p->rtag == 0)
        return  First(p->rchild);
    else
        return p->rchild; // rtage == 1，直接返回后序线索
}

void Inorder(TBTNode *root)
{
    for(TBTNode *p = First(root); p != NULL; p = Next(p))
        cout << p->data; // 访问结点
}

前序线索化二叉树

前序线索化代码和中序线索化代码极为相似，最大的区别就是把连接线索的代码提到了两递归入口前边，这也符合先序递归遍历的框架。

void preThread(TBTNode *p, TBTNode *&pre) // 前序线索化二叉树子函数
{
    if(p != NULL)
    {
        if(p->lchild == NULL)
        {
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL) // pre != NULL 排除第一个结点前驱为空的情况
        {
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
        // 注意，这里在递归入口处有条件限制，左、右指针不是线索才能继续递归
        if(p->ltag == 0)
            preThread(p->lchild, pre); // 递归，左子树线索化
        if(p->rtag == 0)
            preThread(p->rchild, pre); // 递归，右子树线索化
    }
}

void createPreThread(TBTNode *root) // 前序线索化二叉树
{
    TBTNode *pre = NULL;
    if(root != NULL)
    {
        preThread(root, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}

前序遍历线索二叉树

void preorder(TBTNode *root)
{
    if(root != NULL)
    {
        TBTNode *p = root;
        while (p != NULL)
        {
            while (p->ltag == 0) // 左指针不是线索，则边访问边左移
            {
                cout << p->data; // 访问结点
                p = p->lchild; // 左移，访问左子树
            }
            cout << p->data; // 此时p左必为线索，但还没有被访问，则访问
            p = p->rchild; // 此时p左孩子不存在，则右指针若非空，则不论是否为线索都指向其后继
        }
    }
}

后序线索化二叉树

后序线索化代码和中序线索化代码极为相似，最大的区别就是把连接线索的代码提到了两递归入口后边，这也符合后序递归遍历的框架。

void postThread(TBTNode *p, TBTNode *&pre) // 后序线索化二叉树子函数
{
    if(p != NULL)
    {
        preThread(p->lchild, pre); // 递归，左子树线索化
        preThread(p->rchild, pre); // 递归，右子树线索化
        if(p->lchild == NULL)
        {
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL) // pre != NULL 排除第一个结点前驱为空的情况
        {
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
    }
}

后序遍历线索二叉树

考试几乎会不考到后序线索遍历，故省略。
日后有需要的话再来补充。

最后附上源码，希望能对你有所帮助～

#include <stdio.h>
#include <iostream>
using namespace std;

typedef struct TBTNode // 定义线索二叉树的结点
{
    char data; // 结点数据类型
    int ltag, rtag; // 线索标记
    struct TBTNode *lchild; // 左孩子
    struct TBTNode *rchild; // 右孩子
}TBTNode;

TBTNode *createBinaryTree() // 前序递归创建二叉树
{
    TBTNode *p;
    char ch;
    cin >> ch;
    if(ch == '#')
    {
        p = NULL;
    }
    else
    {
        p = (TBTNode*)malloc(sizeof(TBTNode));
        p->data = ch;
        p->lchild = createBinaryTree();
        p->rchild = createBinaryTree();
    }
    return  p;
}

void InThread(TBTNode *p, TBTNode *&pre) // 中序线索化二叉树子函数
{
    if(p != NULL)
    {
        InThread(p->lchild, pre); // 递归，左子树线索化
        if(p->lchild == NULL)
        {
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL) // pre != NULL 排除第一个结点前驱为空的情况
        {
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
        p = p->rchild;
        InThread(p, pre); // 递归，右子树线索化
    }
}

void createInThread(TBTNode *root) // 中序线索化二叉树
{
    TBTNode *pre = NULL;
    if(root != NULL)
    {
        InThread(root, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}

TBTNode *First(TBTNode *p) // 中序遍历线索二叉树-第一个结点访问算法
{
    while (p->ltag == 0)
        p = p->lchild; // 最左下结点（不一定是叶子结点）
    return p;
}

TBTNode *Next(TBTNode *p) // 中序遍历线索二叉树-后继结点访问算法
{
    if(p->rtag == 0)
        return  First(p->rchild);
    else
        return p->rchild; // rtage == 1，直接返回后序线索
}

void Inorder(TBTNode *root) // 中序遍历线索二叉树
{
    for(TBTNode *p = First(root); p != NULL; p = Next(p))
        cout << p->data; // 访问结点
}

void preThread(TBTNode *p, TBTNode *&pre) // 前序线索化二叉树子函数
{
    if(p != NULL)
    {
        if(p->lchild == NULL)
        {
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL) // pre != NULL 排除第一个结点前驱为空的情况
        {
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
        // 注意，这里在递归入口处有条件限制，左、右指针不是线索才能继续递归
        if(p->ltag == 0)
            preThread(p->lchild, pre); // 递归，左子树线索化
        if(p->rtag == 0)
            preThread(p->rchild, pre); // 递归，右子树线索化
    }
}

void createPreThread(TBTNode *root) // 前序线索化二叉树
{
    TBTNode *pre = NULL;
    if(root != NULL)
    {
        preThread(root, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}

void preorder(TBTNode *root) // 前序遍历线索二叉树
{
    if(root != NULL)
    {
        TBTNode *p = root;
        while (p != NULL)
        {
            while (p->ltag == 0) // 左指针不是线索，则边访问边左移
            {
                cout << p->data; // 访问结点
                p = p->lchild; // 左移，访问左子树
            }
            cout << p->data; // 此时p左必为线索，但还没有被访问，则访问
            p = p->rchild; // 此时p左孩子不存在，则右指针若非空，则不论是否为线索都指向其后继
        }
    }
}

void postThread(TBTNode *p, TBTNode *&pre) // 后序线索化二叉树子函数
{
    if(p != NULL)
    {
        preThread(p->lchild, pre); // 递归，左子树线索化
        preThread(p->rchild, pre); // 递归，右子树线索化
        if(p->lchild == NULL)
        {
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL) // pre != NULL 排除第一个结点前驱为空的情况
        {
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
    }
}


int main()
{
    cout << "开始创建二叉树（输入用例：123##5##4##）：" << endl;
    TBTNode *root = NULL;
    root = createBinaryTree();
    cout << "二叉树建立成功！" << endl;
    
    createInThread(root);
    cout << "二叉树中序线索化完成！" << endl;
    cout << "遍历中序线索二叉树：";
    Inorder(root);
    cout << endl;

//    createPreThread(root);
//    cout << "二叉树前序线索化完成！" << endl;
//    cout << "遍历前序线索二叉树：";
//    preorder(root);
//    cout << endl;
    
    return 0;
}
_Pooooooocky
关注
  • 7
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
高薪程序员&Java面试题精讲系列汇总
一一哥
09-24 2834
因为CSDN没有分类归纳博客的功能，所以特写本帖汇总《高薪程序员面试题精讲系列教程》，方便大家查阅！希望各位小伙伴，可以从我的拙作中能对Java的高频面试题有所掌握，也希望各位可以多给与指教！目前本系列文章持续更新中，敬请关注...... 如果你觉得本系列博文对你有帮助，请给个 点赞评论 吧，手写博文不易，一篇文章可能得花一两天的时间才能写好，你的支持是我坚持下去的动力！ 本系列面试题涵盖的内容如下所示： 面试题系列文章链接： 高薪程序员&面试题精讲系列01之开篇介绍 高薪程序员&a.
C语言数据结构之二叉树的非递归后序遍历算法
01-01
C语言数据结构之二叉树的非递归后序遍历算法 前言： 前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一...
线索二叉树(中序、先序和后序及遍历)
达的程序员日记
05-02 1万+
线索二叉树是二叉树的一种。介绍了线索二叉树的三种遍历以及实现。
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
热门推荐
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
从零开始学数据结构和算法(四)哈希表的思想和二叉树入门
2401_84132232的博客
04-19 977
结点拥有的子树数称为结点的度。度为0的结点称为叶子结点或终端结点，度不为0的结点称为非终端结点或分支结点。除根结点以外，分支结点也称为内部结点。树的度是树内各结点的度的最大值。
C++ 数据结构算法 学习笔记(20) - 二叉树
2201_75704074的博客
05-01 922
1024==
数据结构之二叉树
m0_60529319的博客
10-19 209
树状图是一种数据结构，它是由 n（n>=1）个有限结点组成一个具有层次关系的集合。
java开发面试：LinkedList底层数据结构分析、和ArrayList的区别是什么、HashMap（底层数据结构哈希表精讲，put方法、扩容机制源码分析、在java版本中的不同、死循环问题）
zhiaidaidai的博客
12-21 1071
查询：头节点：O(1)，一般情况：O(n)增删：头节点：O(1)，一般情况：O(n)
java容器精讲（Java容器基本说全了），带源码讲解，集合，同步类容器，并发容器，队列
殷志鹏的博客
01-13 968
java几乎所有常用容器介绍，源码解析
150页的剑指Offer解答PDF，它来了！！！
秦怀杂货店
04-24 5926
它来了！！！ 终于整理出了第一版剑指Offer的PDF，主要以Java语言为主，一共67道题，100多页。 领取方式如下（无套路直接获取百度网盘的 ???? 链接,如果链接失效可以直接找我）: 【秦怀杂货店】公众号内发送：剑指Offer 刷题仓库：CodeSolution ，具体的分类如下: 数组 剑指Offer（二）–二维数组中的查找 剑指Offer（十三）–调整数组顺序使奇数位于偶数前面 剑指Offer（十九）-- 顺时针打印矩阵 剑指Offer（二十八）-- 数组中次数出现超过一半的数字 剑指
数据结构实验——二叉树的建立和遍历.zip
12-13
4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问结点的操作修改为叶结点计数，统计度为0的；度为1的；度为2的；总结点数。 6.用递归公式计算二叉树的高度（BiTreeDepth(BT)=0; 当二叉树空时...
JavaScript数据结构与算法之二叉树遍历算法详解【先序、中序、后序】
10-17
主要介绍了JavaScript数据结构与算法之二叉树遍历算法,结合实例形式详细分析了javascript二叉树的定义及先序遍历、中序遍历、后序遍历等相关遍历操作实现技巧,需要的朋友可以参考下
C语言数据结构之线索二叉树及其遍历
08-29
线索二叉树是一种特殊的二叉树结构，它的设计目的是为了在非递归方式下更高效地查找二叉树中节点的前驱和后继。在普通的二叉链表中，节点仅通过左右子节点来表示父子关系，但无法直接获取到在某种遍历顺序（如前序、...
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历）
12-31
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历） 二叉树的性质： 二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。 例： 实例代码： #include #include #include ...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 909
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 217
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 203
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
算法-KMP字符串匹配
xx_xb的博客
07-23 285
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值