简单数据结构的实现之线索二叉树

最新推荐文章于 2023-03-31 23:12:31 发布
最新推荐文章于 2023-03-31 23:12:31 发布
阅读量1.1k 收藏
点赞数
分类专栏： 简单数据结构的实现（C++） 文章标签： 数据结构 thread null class function tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qtyl1988/article/details/6882692
版权

 线索二叉树，我写过的比较恶心的数据结构之一。我一直认为线索化应该是对二叉树的一个操作。可是，线索二叉树与普通的二叉树却实在大有不同。算了，不说了，上代码!

#include <iostream>

using namespace std;

#ifndef TREENODE_H_INCLUDED
#define TREENODE_H_INCLUDED

enum PointerTag
{
    Link,
    Thread
};
template <class ElemType>
class TreeNode
{
private:
    TreeNode* lchild;
    TreeNode* rchild;
    TreeNode* parent;
    PointerTag ltag;
    PointerTag rtag;
public:
    ElemType data;
    TreeNode(const ElemType& item,TreeNode* lptr=NULL,TreeNode* rptr=NULL,PointerTag lt=Link,PointerTag rt=Link,TreeNode* par=NULL):
    lchild(lptr),rchild(rptr),parent(par),ltag(lt),rtag(rt),data(item){ }
    ~TreeNode(){ }
    TreeNode* LeftChild(){return lchild;}
    TreeNode* RightChild(){return rchild;}
    void SetLeftChild(TreeNode* chd){lchild=chd;}
    void SetRightChild(TreeNode* chd){rchild=chd;}
    void SetParent(TreeNode* par){parent=par;}
    TreeNode* Parent(){return parent;}
    PointerTag LeftTag(){return ltag;}
    PointerTag RightTag(){return rtag;}
    void SetLeftTag(PointerTag tag){ltag=tag;}
    void SetRightTag(PointerTag tag){rtag=tag;}
};

#endif // TREENODE_H_INCLUDED
#include <iostream>
#include <list>
#include "treenode.h"

using namespace std;

#ifndef TREELIB_H_INCLUDED
#define TREELIB_H_INCLUDED

template <class ElemType>
TreeNode<ElemType>* GetTreeNode(ElemType item,TreeNode<ElemType>* lptr,TreeNode<ElemType>* rptr)
{
    TreeNode<ElemType>* p=new TreeNode<ElemType>(item,lptr,rptr,Link,Link);
    if(lptr)
    {
        lptr->SetParent(p);
    }
    if(rptr)
    {
        rptr->SetParent(p);
    }
    return p;
}
template <class ElemType>
void FreeNode(TreeNode<ElemType>* t)
{
    delete t;
}
template <class ElemType>
void InThreading(TreeNode<ElemType> * t,TreeNode<ElemType>* &pre)
{
    if(t)
    {
        InThreading(t->LeftChild(),pre);
        if(!t->LeftChild())
        {
            t->SetLeftTag(Thread);
            t->SetLeftChild(pre);
        }
        if(!pre->RightChild())
        {
            pre->SetRightTag(Thread);
            pre->SetRightChild(t);
        }
        pre=t;
        InThreading(t->RightChild(),pre);
    }
}
template <class ElemType>
bool InorderThreading(TreeNode<ElemType> *t,TreeNode<ElemType>* &thrt)
{
    thrt=new TreeNode<ElemType>(' ');
    TreeNode<ElemType>* pre;
    if(!thrt)
    {
        return false;
    }
    thrt->SetLeftTag(Link);
    thrt->SetRightTag(Thread);
    thrt->SetRightChild(thrt);
    if(!t)
    {
        thrt->SetLeftChild(thrt);
    }
    else
    {
        thrt->SetLeftChild(t);
        pre=thrt;
        InThreading(t,pre);
        pre->SetRightTag(Thread);
        pre->SetRightChild(thrt);
        thrt->SetRightChild(pre);
    }
    return true;
}
template <class ElemType>
void PreThreading(TreeNode<ElemType>* t,TreeNode<ElemType>* &pre)
{
    if(t)
    {
        if(!t->LeftChild())
        {
            t->SetLeftTag(Thread);
            t->SetLeftChild(pre);
        }
        if(!pre->RightChild())
        {
            pre->SetRightTag(Thread);
            pre->SetRightChild(t);
        }
        pre=t;
        if(t->LeftTag()==Link)
        {
            PreThreading(t->LeftChild(),pre);
        }
        if(t->RightTag()==Link)
        {
            PreThreading(t->RightChild(),pre);
        }
    }
}
template <class ElemType>
bool PreorderThreading(TreeNode<ElemType> *t,TreeNode<ElemType>* &thrt)
{
    thrt=new TreeNode<ElemType>(' ');
    TreeNode<ElemType>* pre;
    if(!thrt)
    {
        return false;
    }
    thrt->SetLeftTag(Link);
    thrt->SetRightTag(Thread);
    thrt->SetRightChild(thrt);
    if(!t)
    {
        thrt->SetLeftChild(thrt);
    }
    else
    {
        thrt->SetLeftChild(t);
        pre=thrt;
        PreThreading(t,pre);
        pre->SetRightTag(Thread);
        pre->SetRightChild(thrt);
        thrt->SetRightChild(pre);
    }
    return true;
}
template <class ElemType>
void PostThreading(TreeNode<ElemType> *t,TreeNode<ElemType>* &pre)
{
    if(t)
    {
        PostThreading(t->LeftChild(),pre);
        PostThreading(t->RightChild(),pre);
        if(!t->LeftChild())
        {
            t->SetLeftTag(Thread);
            t->SetLeftChild(pre);
        }
        if(!pre->RightChild())
        {
            pre->SetRightTag(Thread);
            pre->SetRightChild(t);
        }
        pre=t;
    }
}
template <class ElemType>
bool PostorderThreading(TreeNode<ElemType> *t,TreeNode<ElemType>* &thrt)
{
    thrt=new TreeNode<ElemType>(' ');
    TreeNode<ElemType>* pre;
    if(!thrt)
    {
        return false;
    }
    thrt->SetLeftTag(Link);
    thrt->SetRightTag(Thread);
    thrt->SetRightChild(thrt);
    if(!t)
    {
        thrt->SetLeftChild(thrt);
    }
    else
    {
        thrt->SetLeftChild(t);
        pre=thrt;
        PostThreading(t,pre);
        thrt->SetRightChild(pre);
    }
    return true;
}
template <class ElemType>
int CountLeaf(TreeNode<ElemType>* t)
{
    if(t)
    {
        if(t->LeftTag()==Thread&&t->RightTag()==Thread)
        {
            return 1;
        }
        if(t->LeftTag()==Link&&t->RightTag()==Thread)
        {
            return CountLeaf(t->LeftChild());
        }
        if(t->LeftTag()==Thread&&t->RightTag()==Link)
        {
            return CountLeaf(t->RightChild());
        }
        return CountLeaf(t->LeftChild())+CountLeaf(t->RightChild());
    }
    else
    {
        return 0;
    }
}
template <class ElemType>
int CountNode(TreeNode<ElemType>* t)
{
    if(t)
    {
        if(t->LeftTag()==Thread&&t->RightTag()==Thread)
        {
            return 1;
        }
        if(t->LeftTag()==Link&&t->RightTag()==Thread)
        {
            return CountNode(t->LeftChild())+1;
        }
        if(t->LeftTag()==Thread&&t->RightTag()==Link)
        {
            return CountNode(t->RightChild())+1;
        }
        return CountNode(t->LeftChild())+CountNode(t->RightChild())+1;
    }
    else
    {
        return 0;
    }
}
template <class ElemType>
int Depth(TreeNode<ElemType>* t)
{
    int depthleft,depthright,depthval;
    if(!t)
    {
        depthval=0;
    }
    else
    {
        if(t->LeftTag()==Link&&t->RightTag()==Link)
        {
            depthleft=Depth(t->LeftChild());
            depthright=Depth(t->RightChild());
        }
        else if(t->LeftTag()==Link&&t->RightTag()==Thread)
        {
            depthleft=Depth(t->LeftChild());
            depthright=0;
        }
        else if(t->LeftTag()==Thread&&t->RightTag()==Link)
        {
            depthleft=0;
            depthright=Depth(t->RightChild());
        }
        else
        {
            depthleft=depthright=0;
        }
        depthval=1+(depthleft>depthright?depthleft:depthright);
    }
    return depthval;
}
template <class ElemType>
void DeleteTree(TreeNode<ElemType>* t)
{
    if(t)
    {
        if(t->LeftTag()==Link)
        {
            DeleteTree(t->LeftChild());
        }
        if(t->RightTag()==Link)
        {
            DeleteTree(t->RightChild());
        }
        FreeNode(t);
    }
}
template <class ElemType>
void ClearTree(TreeNode<ElemType>* &t)
{
    DeleteTree(t);
    t=NULL;
}

#endif // TREELIB_H_INCLUDED


 

#include <iostream>
#include "treenode.h"

using namespace std;

#ifndef TREESCAN_H_INCLUDED
#define TREESCAN_H_INCLUDED

template <class ElemType>
void PreorderTraverse(TreeNode<ElemType>* thrt,void (*Visit)(ElemType& e))
{
    TreeNode<ElemType>* p=thrt->LeftChild();
    while(p!=thrt)
    {
        Visit(p->data);
        if(p->LeftTag()==Link)
        {
            p=p->LeftChild();
        }
        else
        {
            p=p->RightChild();
        }
    }
}
template <class ElemType>
void InorderTraverse(TreeNode<ElemType>* thrt,void (*Visit)(ElemType& e))
{
    TreeNode<ElemType>* p=thrt->LeftChild();
    while(p!=thrt)
    {
        while(p->LeftTag()==Link)
        {
            p=p->LeftChild();
        }
        Visit(p->data);
        while(p->RightTag()==Thread&&p->RightChild()!=thrt)
        {
            p=p->RightChild();
            Visit(p->data);
        }
        p=p->RightChild();
    }
}
template <class ElemType>
void PostorderTraverse(TreeNode<ElemType>* thrt,void (*Visit)(ElemType& e))
{
    TreeNode<ElemType>* p=thrt->LeftChild();
    TreeNode<ElemType>* par;
    while(p->LeftTag()==Link||p->RightTag()==Link)
    {
        while(p->LeftTag()==Link)
        {
            p=p->LeftChild();
        }
        if(p->RightTag()==Link)
        {
            p=p->RightChild();
        }
    }
    while(p!=thrt)
    {
        Visit(p->data);
        if(!p->Parent())
        {
            break;
        }
        par=p->Parent();
        if(p==par->RightChild()||par->RightTag()==Thread)
        {
            p=par;
        }
        else
        {
            par=par->RightChild();
            while(par->LeftTag()==Link||par->RightTag()==Link)
            {
                while(par->LeftTag()==Link)
                {
                    par=par->LeftChild();
                }
                if(par->RightTag()==Link)
                {
                    par=par->RightChild();
                }
            }
            p=par;
        }
    }
}

#endif // TREESCAN_H_INCLUDED



#include <iostream>
#include <iomanip>
#include "treenode.h"
#include "treelib.h"
#include "treescan.h"

using namespace std;

void Visit(char& x)
{
    cout<<x;
}
int main()
{
    TreeNode<char> *root1,*root2,*root3;
    TreeNode<char>* thrt;
    TreeNode<char> *a,*b,*c,*d,*e,*f,*g,*h,*i;

    d = GetTreeNode('D',(TreeNode<char> *)NULL,(TreeNode<char> *)NULL);
    e = GetTreeNode('E',(TreeNode<char> *)NULL,(TreeNode<char> *)NULL);
    b = GetTreeNode('B',(TreeNode<char> *)NULL, d);
    c = GetTreeNode('C',e, (TreeNode<char> *)NULL);
    a = GetTreeNode('A',b, c);
    root1 = a;
    InorderThreading(root1,thrt);
    cout<<"after executing the function of InorderThreading, "<<endl;
    cout<<"the number of leaves is "<<CountLeaf(root1)<<endl;
    cout<<"the number of nodes is "<<CountNode(root1)<<endl;
    cout<<"the depth of this binary tree is "<<Depth(root1)<<endl;
    cout<<"InorderTraverse result: "<<endl;
    InorderTraverse(thrt,Visit);
    cout<<endl;
    FreeNode(thrt);
    ClearTree(root1);
    cout<<"after executing the function of ClearTree, "<<endl;
    cout<<"the number of leaves is "<<CountLeaf(root1)<<endl;
    cout<<"the number of nodes is "<<CountNode(root1)<<endl;
    cout<<"the depth of this binary tree is "<<Depth(root1)<<endl;

    g = GetTreeNode('G',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    h = GetTreeNode('H',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    i = GetTreeNode('I',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    d = GetTreeNode('D',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    e = GetTreeNode('E',g, (TreeNode<char> *)NULL);
    f = GetTreeNode('F',h, i);
    b = GetTreeNode('B',d, e);
    c = GetTreeNode('C',(TreeNode<char> *)NULL, f);
    a = GetTreeNode('A',b, c);
    root2=a;
    PreorderThreading(root2,thrt);
    cout<<"after executing the function of PreorderThreading, "<<endl;
    cout<<"the number of leaves is "<<CountLeaf(root2)<<endl;
    cout<<"the number of nodes is "<<CountNode(root2)<<endl;
    cout<<"the depth of this binary tree is "<<Depth(root2)<<endl;
    cout<<"PreorderTraverse result: "<<endl;
    PreorderTraverse(thrt,Visit);
    cout<<endl;
    FreeNode(thrt);
    ClearTree(root2);
    cout<<"after executing the function of ClearTree, "<<endl;
    cout<<"the number of leaves is "<<CountLeaf(root2)<<endl;
    cout<<"the number of nodes is "<<CountNode(root2)<<endl;
    cout<<"the depth of this binary tree is "<<Depth(root2)<<endl;

    g = GetTreeNode('G',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    h = GetTreeNode('H',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    i = GetTreeNode('I',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    d = GetTreeNode('D',(TreeNode<char> *)NULL, g);
    e = GetTreeNode('E',h, i);
    f = GetTreeNode('F',(TreeNode<char>*)NULL,(TreeNode<char>*)NULL);
    b = GetTreeNode('B',d, (TreeNode<char> *)NULL);
    c = GetTreeNode('C',e, f);
    a = GetTreeNode('A',b, c);
    root3=a;
    PostorderThreading(root3,thrt);
    cout<<"after executing the function of PostorderThreading, "<<endl;
    cout<<"the number of leaves is "<<CountLeaf(root3)<<endl;
    cout<<"the number of nodes is "<<CountNode(root3)<<endl;
    cout<<"the depth of this binary tree is "<<Depth(root3)<<endl;
    cout<<"PostorderTraverse result: "<<endl;
    PostorderTraverse(thrt,Visit);
    cout<<endl;
    FreeNode(thrt);
    ClearTree(root3);
    cout<<"after executing the function of ClearTree, "<<endl;
    cout<<"the number of leaves is "<<CountLeaf(root3)<<endl;
    cout<<"the number of nodes is "<<CountNode(root3)<<endl;
    cout<<"the depth of this binary tree is "<<Depth(root3)<<endl;
    return 0;
}


treenode.h用于定义线索二叉树的节点类，treelib.h用于实现一些线索二叉树的常用操作，比如说线索化等等，treescan.h包括了线索二叉树的先序、中序和后序遍历。

猫咪的晴天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之：线索二叉树
bandenger的博客
05-22 435
数据结构学习之：线索二叉树线索二叉树1、线索二叉树概述1.1 线索二叉树的使用背景1.2线索二叉树创建原理2、线索二叉树代码实现2.1 线索二叉树创建 线索二叉树 1、线索二叉树概述 1.1 线索二叉树的使用背景 对于一颗二叉树而言（如下图所示），每次我们想要查找二叉树里面的一个节点的时候，我们都必须遍历这棵树，以中序遍历为例，遍历的顺序为4251637，当我们遍历到标号为5这个节点的时候，如果有个指针指向5的前一个节点2或者后一个节点1的话，那么我们跳转到2或者1的效率肯定会大大的提升，那我们在哪里去创建
数据结构-线索二叉树
xhoo 的博客
11-23 1101
解析：
【数据结构】线索二叉树（适用场景+图文推导过程+C语言代码实现）
crr411422的博客
03-31 4834
在实际问题中，如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。我们对二叉树以某种次序遍历使其变为线索二叉树的过程称做是线索化。
数据结构 —— 线索二叉树
m0_62969222的博客
04-16 3137
线索二叉树的意义 对于一个有n个节点的二叉树，每个节点有指向左右孩子的指针域。其中会出现n+ 1个空指针域，这些空间不储存任何事物，浪费着内存的资源。 对于一些需要频繁进行二叉树遍历操作的场合，二叉树的非递归遍历操作过程相对比较复杂，递归遍历虽然简单明了，但是会有额外的开销，对于操作的时间和空间都比较浪费。 我们可以考虑利用这些空地址，存放指向节点在某种遍历次序下的前驱和后继节点的地址。通过这些前驱和后继节点的地址可以知道，从当前位置下一步应该走向哪里。 线索二叉树的定义 指向前驱和后继的指针称为线索
数据结构-线索化二叉树
yao_wen_yu的博客
10-26 5037
文章目录1、什么是线索二叉树2、中序线索化二叉树2.1 中序线索化二叉树实现2.2 中序线索化二叉树遍历实现3、先序线索化二叉树3.1 先序线索化二叉树实现3.2 先序线索化二叉树遍历实现4、后序线索化二叉树4.1 后序线索化二叉树实现4.2 后序线索化二叉树遍历实现 1、什么是线索二叉树 线索二叉树是二叉树的一种，我们先看一个二叉树存储例子。 上图中的 # 是空的，会浪费一部分空间，如果我们希望将这些空的指针充分利用，让各个节点都可以指向自己的前驱结点和后继节点，那就需要使用到线索二叉树。 现有一颗节
数据结构之线索二叉树详细解释
热门推荐
m0_61886762的博客
05-02 2万+
1.1 线索二叉树的原理 我们现在倡导节约型社会，一切都应该以节约为本。但当我们创建二叉树时我们会发现其中一共有两个指针域，有的指针域指向的结构为空，这也就浪费了很多空间
数据结构——线索二叉树
cdz2470的博客
05-04 1236
在二叉树中，查找某种遍历（如前中后序遍历、层次遍历）的前驱后继，在普通的二叉树结构中会显得很麻烦。有两种方法可以解决。1.增加前驱后继两个指针，这样大大增加了空间消耗，不太可取。2.将结点结构变为如下结构。若结点有左子树，left指向左孩子否则指向某种遍历的前驱。若结点有右子树，right指向右孩子，否则指向某种遍历的后继。这样，中序遍历的一个线索二叉树结构为：将一个二叉树中序线索化，类似中序遍历，假如该结点有左节点，向左节点递归。没有左节点时，对该结点进行一系列操作，再向其右节点递归。......
C语言数据结构之线索二叉树及其遍历
08-29
线索二叉树是一种特殊的二叉树结构，它的设计目的是为了在非递归方式下更高效地查找二叉树中节点的前驱和后继。在普通的二叉链表中，节点仅通过...理解线索二叉树的原理和实现，对于深入学习数据结构和算法至关重要。
数据结构之线索二叉树-C语言实现.pdf
最新发布
01-15
总的来说，线索二叉树是一种优化二叉树遍历的数据结构，通过在二叉链表中添加线索，可以避免在遍历时反复查找前驱和后继结点，提高了遍历效率。在C语言中实现线索二叉树需要理解二叉树的结构，并正确处理各种插入和...
C/C++数据结构实现二叉树的遍历与线索二叉树
12-26
使用C/C++实现二叉树的构造、先序遍历、中序遍历、后序遍历、中序线索化、线索化后的中序遍历等基本树操作。
数据结构 | 线索二叉树的原理及创建
"You are worthy! You can do it!"
03-04 3467
1. 为什么要用到线索二叉树？ 我们先来看看普通的二叉树有什么缺点。下面是一个普通二叉树（链式存储方式）： 乍一看，会不会有一种违和感？整个结构一共有 7 个结点，总共 14 个指针域，其中却有 8 个指针域都是空的。对于一颗有 n 个结点的二叉树而言，总共会有 n+1 个空指针域，这个规律使用所有的二叉树。 这么多的空指针域是不是显得很浪费？我们学习数据结构和算法的重点就是在想法设法地提高时间效率和空间利用率。这么多的指针域就这么白白浪费了，太败家了！ 所以我们要想法子好好利用它们，利用它们来
数据结构(14)--线索二叉树的实现
小白的专栏
03-01 7631
参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 1.什么是线索二叉树 空的左孩子指针指向该结点的前驱；空的右孩子指针指向该结点的后继。这种附加的指针值称为线索，带线索的二叉树称为线索二叉树。 在不同的遍历次序下，二叉树中的每个结点一般有不同的前...
[数据结构]线索二叉树
qq_45803411的博客
10-27 648
有关线索二叉树的遍历，查找前驱/后继结点
线索二叉树
TechEngineer的专栏
06-06 2951
一、线索二叉树的原理     通过考察各种二叉链表，不管儿叉树的形态如何，空链域的个数总是多过非空链域的个数。准确的说，n各结点的二叉链表共有2n个链域，非空链域为n-1个，但其中的空链域却有n+1个。如下图所示。 因此，提出了一种方法，利用原来的空链域存放指针，指向树中其他结点。这种指针称为线索。     记ptr指向二叉链表中的一个结点，以下是建立线索的规则：
数据结构--线索二叉树详细讲解与实例分析
lzzw的学习之路
07-26 2672
线索二叉树 思考：在有n个节点的二叉链表中必定有n+1个空链域（下面会说为什么），遍历运算是最重要也是最常用的运算，之前的无论递归与非递归算法实现遍历效率都不算高。能不能利用这未使用的n+1空指针域，设计出提高遍历效率的存储结构？ 观察该树可以发现节点（除了根节点）都有一个直接前...
数据结构——线索二叉树的基本操作
一个巨大的博客
11-28 482
线索二叉树的基本操作 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct Node{ //二叉树的链式存储结点 char data; struct Node *Lchild; struct Node *Rchild; int Ltag; int Rtag; }BiTNode,*BiTree; ...
数据结构：二叉树的操作
碧瑶的博客呀
07-15 345
二叉树采用二叉链表的数据结构，实现以下操作： 二叉树的先序、中序、后序遍历 二叉树的三个遍历采用递归方法，先序表示先遍历根结点，再遍历左子树，然后遍历右子树，中序表示先遍历左子树，再遍历根结点，再遍历右子树，后序表示先遍历左子树，再遍历右子树，再遍历根结点，例如： 此二叉树先序遍历递归过程为到达A，不为空，输出A，调用左子树到达B,不为空，输出B，调用B的左子树到达D,不为空，输出D，调用D的...
数据结构：线索二叉树详解及其Java实现
这种设计使得线索二叉树成为一种高效的数据结构，尤其在实现二叉搜索树、平衡树等场景下，比如AVL树或红黑树，可以简化某些操作的复杂性。 数据结构是计算机科学的基础，它关注数据的组织方式及其操作。数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值