线索化二叉树

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

中序线索化（递归）：

图形解析：

这里写图片描述

代码如下：

//中序线索化
    void InorderThreading()
    {
       Node* prev = NULL;
       _InoderThreading(_root, prev);
    }

void _InoderThreading(Node* cur, Node* & prev)
    {
       if (cur)
       {
           _InoderThreading(cur->_left, prev);
           if (NULL == cur->_left)//当前节点的左节点需要线索化
           {
               cur->_left = prev;
               cur->_leftType = THREAD;
           }
           if (prev && NULL == prev->_right)//当前节点的前驱的右节点需要线索化
           {
               prev->_right = cur;
               prev->_rightType = THREAD;
           }
           prev = cur;//更新prev
           _InoderThreading(cur->_right, prev);
       }
    }

中序遍历中序线索化：

这里写图片描述

代码如下：


    //中序遍历
    void InOrder()
    {
       _InOrder(_root);
       cout << endl;
    }

//中序线索二叉树的中序遍历算法
    void InorderThd()
    {
       Node* cur = _root;
       while (cur)
       {
           //查找最左节点
           while (cur->_leftType == LINK)
           {
               cur = cur->_left;
           }
           cout << cur->_data << " ";
           //方法1
           while (cur->_rightType == THREAD)
           {
               cur = cur->_right;
               if (NULL == cur)
               {
                  return;
               }
               cout << cur->_data << " ";
           }
           //执行到此处-->说明右节点为右子树
           cur = cur->_right;
       }
    }

前序线索化二叉树：

void _PreOrderThreading(Node* cur,Node*& prev)
    {
       if (NULL == cur)
       {
           return;
       }
       if (NULL == cur->_left)
       {
           cur->_left = prev;
           cur->_leftType = THREAD;
       }
       if (prev && NULL == prev->_right)
       {
           prev->_right = cur;
           prev->_rightType = THREAD;
       }
       prev = cur;//更新prev的值

       if (cur->_leftType == LINK)//因为是先线索化后进行递归，为了避免死循环，所以需要判断
       {
           _PreOrderThreading(cur->_left, prev);
       }
       if (cur->_rightType == LINK)
       {
           _PreOrderThreading(cur->_right, prev);
       }
    }

前序遍历前序线索化二叉树：

前序线索化二叉树的前序遍历算法（下面的代码很坑、有问题）：

//前序遍历二叉树
    void PreOrderThd()
    {
       Node* cur = _root;
       while (cur)
       {
           //访问左子树
           while (cur->_leftType == LINK)
           {
               cout << cur->_data << " ";
               cur = cur->_left;
           }
           //此时的cur->_leftType == THREAD
           cout << cur->_data << " ";

           //1.子问题  2.cur->_rightType = THREAD
           while (cur->_rightType == THREAD)
           {
               cur = cur->_right;
               cout << cur->_data << " ";
           }
           cur = cur->_right;//子问题
       }
    }

测试代码1如下：

int array1[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    BinaryTreeThd<int> bt1(array1, sizeof(array1) / sizeof(int), '#');
    bt1.PreOrder();
    bt1.PreOrderThreading();
    bt1.PreOrderThd();

结果如下：

这里写图片描述

测试代码2如下：

  int array[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
    BinaryTreeThd<int> bt(array, sizeof(array) / sizeof(int), '#');
    bt.PreOrder();
    bt.PreOrderThreading();
    bt.PreOrderThd();

这里写图片描述

很明显，结果不对，下面我们来仔细分析其中存在的问题：

这里写图片描述

将上面的程序改之：

//前序遍历二叉树
    void PreOrderThd()
    {
       Node* cur = _root;
       while (cur)
       {
           //访问左子树
           while (cur->_leftType == LINK)
           {
               cout << cur->_data << " ";
               cur = cur->_left;
           }
           //此时的cur->_leftType == THREAD
           cout << cur->_data << " ";

           cur = cur->_right;
       }
    }

测试代码如下：

void TestBinary()
{
    int array1[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    BinaryTreeThd<int> bt1(array1, sizeof(array1) / sizeof(int), '#');
    bt1.PreOrder();
    bt1.PreOrderThreading();
    bt1.PreOrderThd();
    cout << endl;
    int array[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
    BinaryTreeThd<int> bt(array, sizeof(array) / sizeof(int), '#');
    bt.PreOrder();
    bt.PreOrderThreading();
    bt.PreOrderThd();
}

结果如下：

这里写图片描述

代码如下：

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include <assert.h>
using namespace std;

enum PointerType
{
    LINK,
    THREAD,
};

template<class T>
struct BinaryTreeThdNode
{
    BinaryTreeThdNode(const T& value)
    :_data(value)
    , _left(NULL)
    , _right(NULL)
    , _leftType(LINK)
    , _rightType(LINK)
    {}

    T _data;
    BinaryTreeThdNode<T>* _left;
    BinaryTreeThdNode<T>* _right;

    PointerType _leftType;//标记是否需要线索化
    PointerType _rightType;
};

template<class T>
class BinaryTreeThd
{
    typedef BinaryTreeThdNode<T> Node;
public:
    BinaryTreeThd(const Node* node)
       :_root(node)
    {}
    BinaryTreeThd(const T* arr, size_t size, const T& invalid)
    {
       size_t index = 0;
       _root = _CreatTree(arr, size, invalid, index);
    }

    //先序遍历
    void PreOrder()
    {
       _PreOrder(_root);
       cout << endl;
    }

    //中序遍历
    void InOrder()
    {
       _InOrder(_root);
       cout << endl;
    }
    //后序遍历
    void PostOrder()
    {
       _PostOrder(_root);
       cout << endl;
    }

    //中序线索化
    void InorderThreading()
    {
       Node* prev = NULL;
       _InoderThreading(_root, prev);
    }
//中序线索二叉树的中序遍历算法
    void InorderThd()
    {
       Node* cur = _root;
       while (cur)
       {
           //查找最左节点
           while (cur->_leftType == LINK)
           {
               cur = cur->_left;
           }
           cout << cur->_data << " ";
           //方法1
           while (cur->_rightType == THREAD)
           {
               cur = cur->_right;
               if (NULL == cur)
               {
                  return;
               }
               cout << cur->_data << " ";
           }
           //执行到此处-->说明右节点为右子树
           cur = cur->_right;
       }
    }

    //前序线索二叉树的前序遍历算法
    void PreOrderThreading()
    {
       Node* prev = NULL;
       _PreOrderThreading(_root, prev);
       if (NULL == prev)
       {
           prev->_rightType = THREAD;
       }
    }

    void PreOrderThd()
    {
       if (NULL == _root)
       {
           return;
       }

       Node* cur = _root;
       while (cur)
       {
           //访问根节点
           cout << cur->_data << " ";
           //访问左子树
           while (cur->_leftType == LINK)
           {
               cur = cur->_left;
               cout << cur->_data << " ";
           }
           //此时的cur->_leftType == THREAD

           while (cur->_rightType == THREAD)
           {
               cur = cur->_right;
               cout << cur->_data << " ";
           }
           cur = cur->_right;//子问题
       }
    }

    //后序线索化二叉树
    void PostOrderThreading()
    {
       Node* prev = NULL;
       _PostOrderThreading(_root,prev);
    }

    //后序遍历
    void PostOrderThd()
    {
       if (NULL == _root)
       {
           return;
       }
       Node* cur = NULL;
       while (cur)
       {
           while (LINK == cur->_leftType || Link == cur->_rightType)
           {
               if (LINK == cur->_leftType)
               {
                  cur = cur->_left;
               }
               if (LINK == cur->_rightType)
               {
                  cur = cur->_right;
               }
           }
           cout << cur->_data << " ";

           Node* p = NULL;

       }

    }

protected:
    //左、右、根
    void _PostOrderThreading(Node* cur,Node*& prev)
    {
       if (NULL == cur)
       {
           return;
       }
           _PostOrderThreading(cur->_left, prev);
           _PostOrderThreading(cur->_right, prev);
       if (NULL == cur->_left)
       {
           cur->_left = prev;
           cur->_leftType = THREAD;
       }
       if (prev && NULL == prev->_right)
       {
           prev->_right = cur;
           prev->_rightType = THREAD;
       }
       prev = cur;//更新prev的值
    }

    void _PreOrderThreading(Node* cur,Node*& prev)
    {
       if (NULL == cur)
       {
           return;
       }
       if (NULL == cur->_left)
       {
           cur->_left = prev;
           cur->_leftType = THREAD;
       }
       if (prev && NULL == prev->_right)
       {
           prev->_right = cur;
           prev->_rightType = THREAD;
       }
       prev = cur;//更新prev的值

       if (cur->_leftType == LINK)//因为是先线索化后进行递归，为了避免死循环，所以需要判断
       {
           _PreOrderThreading(cur->_left, prev);
       }
       if (cur->_rightType == LINK)
       {
           _PreOrderThreading(cur->_right, prev);
       }
    }

    void _PreOrder(Node* root)
    {
       if (root)
       {
           cout << root->_data << " ";
           _PreOrder(root->_left);
           _PreOrder(root->_right);
       }
    }

    void _InOrder(Node* root)
    {
       if (root)
       {
           _InOrder(root->_left);
           cout << root->_data << " ";
           _InOrder(root->_right);
       }
    }

    void _PostOrder(Node* root)
    {
       if (root)
       {
           _PostOrder(root->_left);
           _PostOrder(root->_right);
           cout << root->_data << " ";
       }
    }

    void _InoderThreading(Node* cur, Node* & prev)
    {
       if (cur)
       {
           _InoderThreading(cur->_left, prev);
           if (NULL == cur->_left)//当前节点的左节点需要线索化
           {
               cur->_left = prev;
               cur->_leftType = THREAD;
           }
           if (prev && NULL == prev->_right)//当前节点的前驱的右节点需要线索化
           {
               prev->_right = cur;
               prev->_rightType = THREAD;
           }
           prev = cur;//更新prev
           _InoderThreading(cur->_right, prev);
       }
    }

    Node* _CreatTree(const T* arr, size_t size, const T& invalid, size_t& index)
    {
       Node* newRoot = _root;
       if (index < size && arr[index] != invalid)
       {
           newRoot = new Node(arr[index]);
           newRoot->_left = _CreatTree(arr, size, invalid, ++index);
           newRoot->_right = _CreatTree(arr, size, invalid, ++index);
       }
       return newRoot;
    }

private:
    Node* _root;
};

前序线索化二叉树：

void _PreOrderThreading(Node* cur,Node*& prev)
    {
       if (NULL == cur)
       {
           return;
       }
       if (NULL == cur->_left)
       {
           cur->_left = prev;
           cur->_leftType = THREAD;
       }
       if (prev && NULL == prev->_right)
       {
           prev->_right = cur;
           prev->_rightType = THREAD;
       }
       prev = cur;//更新prev的值

       if (cur->_leftType == LINK)//因为是先线索化后进行递归，为了避免死循环，所以需要判断
       {
           _PreOrderThreading(cur->_left, prev);
       }
       if (cur->_rightType == LINK)
       {
           _PreOrderThreading(cur->_right, prev);
       }
    }

中序线索化二叉树的迭代器：

template<class T>
struct BinaryTreeThdIterator
{
    typedef BinaryTreeThdNode<T> Node;
    typedef BinaryTreeThdIterator<T> self;

    BinaryTreeThdIterator(Node* node)
       :_node(node)
    {}

    T& operator*()
    {
       return _node->_data;
    }

    T* operator->()
    {
       return &(_node->_data);
    }

    self& operator++()
    {
       //后继
       if (_node->_rightType == THREAD)
       {
           _node = _node->_right;
       }
       else//子问题
       {
           Node* cur = _node->_right;
           while (cur->_leftType == LINK)
           {
               cur = cur->_left;
           }
           _node = cur;
       }
       return *this;
    }

    bool operator!=(const self& cur)const
    {
       return _node != cur._node;
    }

    bool operator==(const self& cur)const
    {
       return _node == cur._node;
    }

    Node* _node;
};

总结：
本文概要：1.中序线索化二叉树
2.中序遍历中序线索化二叉树
3.前序线索化二叉树
4.前序遍历前序线索化二叉树（易入坑）
5.中序线索化二叉树的迭代器

小葱1024
关注
专栏目录
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
storyfull
12-28 3066
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
线索二叉树怎么画_【红黑树】背了又忘？深入本质，他也不过是一棵二叉树
weixin_39605278的博客
12-04 104
前言小松最近好久没有更新文章了，是小松懒了吗？是的自从小松拿到了公司的测试机，近5000的小米10 Pro，还有因为内推几十个人得到的airpods pro奖品，还有公司每月发的Q币和点券，于是我的周末变成了这样。早上10点来公司，信心满满准备好好学一天，看到小米10，心想，要不玩一把王者？公司的网还贼好，下载近5~6m/s，开局全程50延迟以下，然后打开mac，上爱奇艺播放4k杜比漫威大片，在2...
线索二叉树怎么画_算法素颜（13）：精通二叉树的“独门忍术”——线索二叉树（上）...
weixin_39944375的博客
11-24 495
引言二叉树的叶子节点的孩子都是空节点(Null)，如果展开显示，如下图：图 1 原始二叉树二叉树的遍历方法，有“前序遍历”“中序遍历”和“后序遍历”三种。“前序遍历”的规则：先访问当前节点，再访问其左子树，最后访问右子树；访问子树时，按照规则1递归执行。“中序遍历”的规则：先访问左子树，再访问当前节点，最后访问右子树；访问子树时，按照规则1递归执行。“后序遍历”的规则：先访问左子树、再访问右子树，...
线索二叉树(前中后序线索化/遍历/画线索)
最新发布
Curz酥的博客
05-01 1万+
考研数据结构笔记。线索二叉树(前中后序线索化/遍历/画线索)
线索二叉树，画图教你秒懂线索二叉树（线索二叉树的建立和简单操作）逻辑代码分析
qq_46104786的博客
11-16 1万+
数据结构专升本学习,线索二叉树 前言 前面我们学习树和二叉树的一些基本操作，今天我们学习一个新的知识，学习一下线索二叉树，线索二叉树是由二叉链存储结构变化而来的（我们先得有个二叉链树，再做处理），就是将原来的空域链改为莫种遍历次序下该结点的前驱结点和后继结点的指针，就相当于把我们的空域也利用起来指向下一个要输出的结点，对于下一个结点提高了访问速度，emmm，有点难，博主也有点云里雾里，看博主的解释能不能让你理解。嘿嘿 每日一遍，快乐学习 你们第一次炒菜是不是也是这个样纸！！！！哈哈哈哈 1.什么是线索二叉
已知前序遍历序列和后序遍历序列，不能确定一棵二叉树！
qfturauyls的博客
07-16 1万+
【结论】：已知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树 已知后序遍历序列和中序遍历序列，可以唯一确定一棵二叉树 但是已知前序遍历序列和后序遍历序列，是不能确定一棵二叉树的 即：没有中序遍历序列的情况下是无法确定一颗二叉树的 【例题】下面例子通过前序遍历和中序遍历确定唯一的一棵二叉树。 前序遍历：EACBDGF 中序遍历：ABCDEFG1、首先根据前序遍历找出根节点是E，然后...
中序线索化二叉树的非递归算法.doc
09-12
中序线索化二叉树的非递归算法 中序线索化二叉树的非递归算法是指对二叉树进行中序遍历，并将其转换为线索化二叉树的算法。这里，我们将详细介绍该算法的实现过程和相关知识点。 算法思想 中序线索化二叉树的非...
线索化二叉树C实现代码
02-24
线索化二叉树是一种特殊的二叉树数据结构，它的主要目的是为了在非递归的情况下能够进行二叉树的前序、中序和后序遍历。这种数据结构通过利用二叉树结点中的空指针域，即通常的`left`和`right`指针，来附加线索，...
线索化二叉树和遍历（中序）
weixin_45713331的博客
08-27 1124
线索化二叉树，按照前序，中序，后序的排列方式，给某些左右节点为空的节点设置了前驱和和后继节点。遍历：因为线索化了二叉树对其中序遍历时，以前的方法会出错。
二叉树线索化以及线索化的先序、中序、后序遍历
CodingStart
08-01 5万+
二叉树线索化以及线索化的先序、中序、后序遍历 有详细的图解 和 程序代码 解读，以及 为什么要线索化二叉树
线索二叉树
TechEngineer的专栏
06-06 2960
一、线索二叉树的原理     通过考察各种二叉链表，不管儿叉树的形态如何，空链域的个数总是多过非空链域的个数。准确的说，n各结点的二叉链表共有2n个链域，非空链域为n-1个，但其中的空链域却有n+1个。如下图所示。 因此，提出了一种方法，利用原来的空链域存放指针，指向树中其他结点。这种指针称为线索。     记ptr指向二叉链表中的一个结点，以下是建立线索的规则：
[数据结构]——线索二叉树
qq_45902301的博客
12-16 7532
这篇文章介绍了在数据结构中，如何作出线索二叉树。
后序线索化二叉树及遍历（图解）
热门推荐
CodingStart
08-01 7万+
线索二叉树的后序遍历详细介绍，图解，特别适合初学者，以及懒得画图的童鞋了
图解线索二叉树
weixin_44067399的博客
07-07 2万+
今天我们来聊聊线索二叉树 线索二叉树的诞生背景 对于n个结点的二叉树，则在二叉链存储结构中就会有n+1个空链域 当我在查找某个结点的时候，想要知道这个节点的前驱结点或者后继结点，我该怎么做？ 1.我是不是可以先序遍历或者后序遍历得到他们的前驱或者后继 2.我是不是可以开辟内存空间，对于每个结点增加一个指向它的前驱，增加一个指向它的后继 利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。 关于线索二叉树你所需要知道的 重要 如果一个结点的
线索化二叉树的画法
weixin_60321921的博客
06-20 7590
线索化二叉树画法
数据结构-线索二叉树（后序线索二叉树及遍历）
[SZU_Crayon]
07-20 4万+
后序线索二叉树 线索化的概念及相关图解 在上一篇中详细介绍了中序线索二叉树，线索化图解及相关概念都放在那篇博客啦，放个传送门 线索二叉树详细解析（含图解）：传送门 包括还有先序线索二叉树：传送门   后序线索二叉树 （1）后序线索二叉树的构造              ①思路：在这里说下构造的原因，与先序中序线索二叉树不同，在遍历时后序时先把孩子全部遍历了再回到父...
C语言实现的线索化二叉树及其遍历
本篇文章详细介绍了如何在C语言环境下实现线索化二叉树的数据结构和算法。线索化二叉树是一种特殊的二叉树存储结构，通过额外的信息（线索）来辅助遍历操作，使得在遍历时可以更方便地追踪前驱和后继节点，从而简化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值