二叉树线索化

最新推荐文章于 2023-04-05 17:05:10 发布
最新推荐文章于 2023-04-05 17:05:10 发布
阅读量980 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hudazhe/article/details/78723745
版权

首先提出一个问题 为什么要线索化二叉树？

二叉树遍历的本质上是将一个复杂的非线性结构转换为线性结构，使每个节点都有了唯一前驱和后继(第一个节点无前驱，最后一个节点无后继)。对于一个节点，查找其左右子树是方便的，但是查找其前驱和后继只能在遍历中找到。
线索化二叉树解决了无法直接找到该节点在某种遍历序列中的前驱和后继节点的问题。

可以在节点结构中增加前驱和后继的指针，但是增加了存储开销。另一种方法是利用二叉树的空链指针。在这里我们使用第二种方法。

同二叉树的遍历相同，二叉树的线索化也可分为前序线索化，中序线索化，后序线索化，每一种线索化同时对应着一种遍历方式。

前序线索化
这里写图片描述
线索化即找到它的前驱和后继，我们要利用二叉树中的空链，但是还要和原来的非空节点加以区分，所以在这里给出一个新的结构，里面标识了其左右子树是否被标记为前驱或后继。

enum Tag //标记
{
    Link,
    Thread
};
template<class T>
struct BinaryTreeNode
{
public:
    BinaryTreeNode()
        :_data(NULL)
    {}
    BinaryTreeNode(T &t){ //
        _data = t;
    }
public:
    T _data;
    BinaryTreeNode<T> *leftChild;    //左节点
    BinaryTreeNode<T> *rightChild;   //右节点
    Tag leftTag = Link;    //左标记
    Tag rightTag = Link;    //右标记
};

在创建好二叉树，每个节点的左右标记都应该为 Link，此时对二叉树进行遍历，如果左节点为空，则让它的左节点指向他的前驱，如果右节点为空，则让他的右节点指向他的后继。
前驱我们在遍历的时候可以很好的找到，但是后继我们却无法直接访问到。所以我们需要一个节点来记录下来此节点的前驱 prev，如果前驱的右节点为空，则让前驱 prev 的右节点指向此节点。
实现：

enum Tag
{
    Link,
    Thread
};

template<class T>
struct BinaryTreeNode
{
public:
    BinaryTreeNode()
        :_data(NULL)
    {}
    BinaryTreeNode(T &t)
    {
        _data = t;
    }
public:
    T _data;
    BinaryTreeNode<T> *leftChild;    //左节点
    BinaryTreeNode<T> *rightChild;   //右节点
    Tag leftTag = Link;    //左标记
    Tag rightTag = Link;    //右标记

};
template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        :_root(NULL)
    {}
    BinaryTree(T* a, size_t n, const T &invalid)
    {
        size_t index = 0;  //从根节点开始传入
        _root = CheckTree(a, n, invalid, index);    // m  数组大小  invalid非法值   index 构建的位置
    }
protected:
    Node * CheckTree(T *a, size_t n, const T& invalid, size_t &index) {     //二叉树初始化
        Node *t = NULL;
        if (a[index] != invalid && index < n) {    // 如果不是# 或者未到达边界
            t = new Node(a[index]);
            t->leftChild = CheckTree(a, n, invalid, ++index);  //左子树
            t->rightChild = CheckTree(a, n, invalid, ++index);  //右子树
        }
        return t;
    }
public:
    void PrevOrderTherading()  //前序线索化
    {
        Node *prev = NULL;
        _PrevOrderTherading(_root, prev);
    }
private:
    void _PrevOrderTherading(BinaryTreeNode<T> *root, Node*& prev)
    {
        if (root == NULL)
            return;
        if (root->leftChild == NULL)
        {
            root->leftChild = prev;
            root->leftTag = Thread;
        }
        if (prev != NULL&&prev->rightChild == NULL)
        {
            prev->rightChild = root;
            prev->rightTag = Thread;
        }
        prev = root;
        if (root->leftTag == Link)
            _PrevOrderTherading(root->leftChild, prev);
        if (root->rightTag == Link)
            _PrevOrderTherading(root->rightChild, prev);
    }
    void _InOrderTherading(BinaryTreeNode<T> *root, Node*& prev)
    {
        if (root == NULL) {
            return;
        }
        _InOrderTherading(root->leftChild, prev);// 左子树   prev前驱
        if (root->leftChild == NULL) {
            root->leftTag = Thread;         //如果左为空，需要前驱
            root->leftChild = prev;
        }
        if (prev != NULL&&prev->rightChild == NULL)
        {
            prev->rightChild = root;   //如果右为空 需要后继
            prev->rightTag = Thread;
        }
        prev = root;
        _InOrderTherading(root->rightChild, prev);//右树
    }
private:
    Node *_root;
};

此时二叉树已经前序线索化完成，但是线索化之后，我们还需要对其进行遍历。在遍历中，由于我们是依次向后遍历，所以在这里我们不需要对前驱节点进行访问。
这里写图片描述
可以看出，我们可以直接访问到根结点的左子树，之后利用其后继节点依次访问就可以了。

void PreOrder()  //先序遍历线索化二叉树
    {
        if (_root == NULL) return;
        Node *cur = _root;
        while (cur->leftTag != Thread) //先遍历到左子树
        {
            cout << cur->_data << " ";
            cur = cur->leftChild;
        }
        while (cur) //后继节点访问
        {
            cout << cur->_data << " ";
            cur = cur->rightChild;
        }
    }

中序线索化
这里写图片描述
与前序线索化相同，也是利用前驱和后继来对节点的空节点进行处理。

enum Tag
{
    Link,
    Thread
};

template<class T>
struct BinaryTreeNode
{
public:
    BinaryTreeNode()
        :_data(NULL)
    {}
    BinaryTreeNode(T &t)
    {
        _data = t;
    }
public:
    T _data;
    BinaryTreeNode<T> *leftChild;    //左节点
    BinaryTreeNode<T> *rightChild;   //右节点
    Tag leftTag = Link;    //左标记
    Tag rightTag = Link;    //右标记

};
template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        :_root(NULL)
    {}
    BinaryTree(T* a, size_t n, const T &invalid)
    {
        size_t index = 0;  //从根节点开始传入
        _root = CheckTree(a, n, invalid, index);    // m  数组大小  invalid非法值   index 构建的位置
    }
protected:
    Node * CheckTree(T *a, size_t n, const T& invalid, size_t &index) {     //二叉树初始化
        Node *t = NULL;
        if (a[index] != invalid && index < n) {    // 如果不是# 或者未到达边界
            t = new Node(a[index]);
            t->leftChild = CheckTree(a, n, invalid, ++index);  //左子树
            t->rightChild = CheckTree(a, n, invalid, ++index);  //右子树
        }
        return t;
    }
public:
    //线索化 前驱后继
    //中序线索化
    void InOrderTherading() {
        BinaryTreeNode<T> *prev = NULL;
        _InOrderTherading(_root,prev);
    }
private:
    void _InOrderTherading(BinaryTreeNode<T> *root,Node*& prev)
    {
        if (root == NULL) {
            return;
        }
        _InOrderTherading(root->leftChild,prev);// 左子树   prev前驱
        if (root->leftChild == NULL) {
            root->leftTag = Thread;         //如果左为空，需要前驱
            root->leftChild = prev;
        }
        if (prev != NULL&&prev->rightChild == NULL)
        {
            prev->rightChild = root;   //如果右为空 需要后继
            prev->rightTag = Thread;
        }
        prev = root;
        _InOrderTherading(root->rightChild, prev);//右树
    }
private:
    Node *_root;
};

中序线索化遍历
同前序线索化遍历相同，我们不需要前驱节点。但是如果使用和前序遍历相同的方法，会造成死循环。所以此时我们需要节点的左右标记来进行区分是否需要访问它的左树或右树。
这里写图片描述

void InOrder()
    {// 中序线索化遍历
        if (_root == NULL)
            return;
        Node* cur = _root;
        while (cur)
        {
            while (cur->leftTag == Link) //先遍历到左树
                cur = cur->leftChild;
            cout << cur->_data << " ";
            while (cur&&cur->rightTag == Thread)
            {
                cur = cur->rightChild;
                cout << cur->_data << " ";
            }
            cur = cur->rightChild;  // 没有后继，则存在右子树
        }
    }

后序线索化
与之前相类似。
实现：
这里写图片描述

enum Tag
{
    Link,
    Thread
};

template<class T>
struct BinaryTreeNode
{
public:
    BinaryTreeNode()
        :_data(NULL)
    {}
    BinaryTreeNode(T &t)
    {
        _data = t;
    }
public:
    T _data;
    BinaryTreeNode<T> *leftChild;    //左节点
    BinaryTreeNode<T> *rightChild;   //右节点
    Tag leftTag = Link;    //左标记
    Tag rightTag = Link;    //右标记

};
template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        :_root(NULL)
    {}
    BinaryTree(T* a, size_t n, const T &invalid)
    {
        size_t index = 0;  //从根节点开始传入
        _root = CheckTree(a, n, invalid, index);    // m  数组大小  invalid非法值   index 构建的位置
    }
protected:
    Node * CheckTree(T *a, size_t n, const T& invalid, size_t &index) {     //二叉树初始化
        Node *t = NULL;
        if (a[index] != invalid && index < n) {    // 如果不是# 或者未到达边界
            t = new Node(a[index]);
            t->leftChild = CheckTree(a, n, invalid, ++index);  //左子树
            t->rightChild = CheckTree(a, n, invalid, ++index);  //右子树
        }
        return t;
    }
public:
    //线索化 前驱后继
    //后序线索化
    void PostOrderTherading() {
        BinaryTreeNode<T> *prev = NULL;
        _PostOrderTherading(_root, prev);
    }
private:
    void _PostOrderTherading(BinaryTreeNode<T> *root, Node*& prev)
    {
        if (root == NULL) {
            return;
        }
        _PostOrderTherading(root->leftChild, prev);// 左子树   prev前驱
        _PostOrderTherading(root->rightChild, prev);//右树
        if (root->leftChild == NULL) {
            root->leftTag = Thread;         //如果左为空，需要前驱
            root->leftChild = prev;
        }
        if (prev != NULL&&prev->rightChild == NULL)
        {
            prev->rightChild = root;   //如果右为空 需要后继
            prev->rightTag = Thread;
        }
        prev = root;
    }
private:
    Node *_root;
};

后序线索化遍历
同样先去掉前驱节点，但是此时我们无法直接依靠节点去依次访问后继节点，在这里我们需要一个栈来保存未被访问的根节点，如果某个节点的后继与栈顶元素相同，则可以出栈，如果后继节点与根节点 _root 相同，则输出根节点后便可以退出程序。
这里写图片描述
实现：

void PostOrder()
    {
        stack<Node *> s;
        Node *cur = _root;
        do
        {
            while (cur->leftTag == Link)  // 先遍历到左树
            {
                s.push(cur);
                cur = cur->leftChild;
            }
            while (cur->rightTag == Thread)  //如果右树是后继则依靠后继遍历
            {
                cout << cur->_data << " ";
                cur = cur->rightChild;
                if (cur->_data == s.top()->_data) // 如果与栈顶相同 说明需要出栈
                {
                    cout << cur->_data<<" ";
                    s.pop();
                    if (cur->rightChild == _root)  // 如果此时节点的后继为根节点 则可以直接输出并结束
                    {
                        cout << cur->rightChild->_data << " ";
                        return;
                    }
                }
            }
            if (!s.empty())  //循环走出后取栈顶元素
            {
                cur = s.top();
                cur = cur->rightChild;
            }
        } while (cur != _root);
    }
胡小哲
关注
专栏目录
数据结构—二叉树线索化(线索化的先序、中序、后序遍历)
小虾米编程
07-14 1万+
1.线索二叉树基本概念 二叉树是一种非线性结构，遍历二叉树几乎都是通过递归或者用栈辅助实现非递归的遍历。用二叉树作为存储结构时，取到一个节点，只能获取节点的左孩子和右孩子，不能直接得到节点的任一遍历序列的前驱或者后继。 为了保存这种在遍历中需要的信息，我们利用二叉树中指向左右子树的空指针来存放节点的前驱和后继信息，n个节点的二叉树中含有n+1个空指针域。 试做如下规定： 若结点有左子树，...
线索化二叉树详解与代码实现
IronmanJay的博客
01-17 499
文章目录一、问题提出二、线索二叉树基本介绍三、线索二叉树应用案例四、中序线索化二叉树代码实现五、代码运行结果 一、问题提出 当我们对上面的二叉树进行中序遍历时，数列为{8，3，10，1，6，14} 但是6，8，10，14这几个节点的左右指针（红色箭头），并没有完全的利用上 如果我们希望充分的利用各个节点的左右指针，并且让各个节点可以指向自己的前后节点，怎么办？ 二、线索二叉树基本介绍 n个节点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向该节点在某种遍历次序下的前驱和后继节点的
利用栈实现线索化二叉树_javascript线索化二叉树
weixin_30585729的博客
01-27 225
线索化二叉树数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树(中序遍历的数列为 {8, 3, 10, 1, 14, 6}). n+1=7线索二叉树基本介绍1.n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）2.这种加上了线索的二叉链表称...
二叉树的线索化
热门推荐
编程小霸王的Blog
12-05 2万+
线索二叉树(Threaded BinaryTree) 1.线索二叉树的基本概念       遍历二叉树是以一定规则将二叉树中的结点排列成一个线性序列，得到二叉树中结点的先序序列、中序序列或后序序列。 这实质上是对一个非线性结构进行线性化操作。使每个结点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。      例如二叉树结点的中序序列a+b*c-d-e/f中，“c”
AVL.rar_二叉树 线索化_线索二叉树
09-24
中序线索化的二叉树 能够对二叉树先线索化然后再中序排列 并且输出
实验3-二叉树线索化.docx
05-24
实验3-二叉树线索化 本实验报告的主要内容是介绍二叉树的结构和一些基本操作，如二叉树的中序线索化、先序线索化、后序线索化，以及二叉树的建立、中序遍历线索化二叉树、先序遍历线索化二叉树等等。下面是实验报告...
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
线索化二叉树
weixin_34106122的博客
04-26 61
#define_CRT_SECURE_NO_WARNINGS1 #include<iostream> usingnamespacestd; enumPointerTag{THREAD,LINK};//枚举 前言：为了遍历的方便，我们在二叉树中引入前驱和后序，这样就储存了相关信息。 其结构如下：template<classT...
线索二叉树的画法
m0_52001011的博客
04-05 3653
在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。
二叉树线索化中序遍历
最新发布
10-18
二叉树线索化是将二叉树中的空指针利用起来，将其转化为指向前驱或后继节点的线索，以便快速遍历二叉树。线索化后的二叉树可以支持前序、中序、后序和层序遍历。 对于中序遍历，线索化的过程如下： 1. 对于节点p，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值