线索二叉树

将二叉树线索化，实际上就是将其变为一个循环链表，下面的代码是采用中序的线索化，遍历也是中序遍历，都是基于中序的。

在中序遍历序列中求某一结点的前驱和后继的方法：（1）求某一结点的后继：如果所考虑的结点有右孩子，那么就要从该右孩子开始，顺着右孩子的左孩子域找下去，一直到左孩子域为空为止，最后这个结点就是所考虑结点的后继；如果所考虑的结点没有右孩子，那么就要遍历二叉树。（2）求某一结点前驱：如果所考虑结点有左孩子，那么就要从该左孩子开始，顺着该左孩子的右孩子链域找下去，一直到右孩子的链域为空为止，最后这个结点就是所考虑结点的前驱；然后该结点没有左孩子，那么就要遍历二叉树。

下面代码中还有一个要说的就是用来辅助搜索的Address结构体数组，一开始我本来是乡写一个函数，直接就是在遍历的过程中搜索指定数值的结点，但是有时对有时错，搞了一个下午都不知怎么搞好，就放弃了，采用这个结构体数组的方法，简单一些，那个等以后老师讲的时候再看看老师会怎么实现吧，可能会有灵感。

中序遍历，建立线索二叉树

#include<iostream>
using namespace std;
 
class ThreadTree;//线索二叉树
 
class Thrnode
{
private:
    int data;
    int ltag;    //ltag为0:表示lchild为一般二叉树的指针，指向其左子树
    int rtag;    //ltag为1:表示lchild为指向此结点的前驱的指针，rtag同理
    Thrnode *lchild;
    Thrnode *rchild;
    
    friend class ThreadTree;
};
 
int num=0;//记录结点数目
struct Address        //辅助搜索
{
    int data;
    Thrnode *p;
}ad[100];
 
class ThreadTree
{
private:
    Thrnode *root;
public:
    ThreadTree()
    {
        root=0;
    }
 
    Thrnode *Get_Root()
    {
        return root;
    }
 
    int Get_data(Thrnode *p)
    {
        return p->data;
    }
 
    Thrnode *Create_Tree(Thrnode *r)    //先序建立二叉树
    {
        int d;
        cout<<"输入数据(0代表空)：";
        cin>>d;
        if(d==0)
            return 0;
        else
        {
            num++;
            r=new Thrnode;
            r->ltag=0;
            r->rtag=0;
            r->data=d;
            r->lchild=Create_Tree(r->lchild);
            r->rchild=Create_Tree(r->rchild);
        }
        root=r;
        return r;
    }
 
    void In_Threading(Thrnode *p,Thrnode *&pre)
    {
        //以指针p所指向的二叉树进行中序遍历，遍历过程中进行线索化
        //pre指针是p的前驱指针
        if(p)
        {
            In_Threading(p->lchild,pre);//左子树线索化
            if(!p->lchild) //若p的左子树为空，给p结点加前驱线索
            {
                p->ltag=1;
                p->lchild=pre;
            }
            else
                p->ltag=0;
            if(pre && !pre->rchild)
            {
                pre->rtag=1;
                pre->rchild=p;
            }
            pre=p;
            In_Threading(p->rchild,pre); //右子树线索化
        }
 
    }
 
    Thrnode *InOrder_Threading(Thrnode *r) //将二叉树线索化，按中序遍历的顺序
    {
        //遍历二叉树，并将其中序线索化，其中，Thrt指针指向头结点，r指向根节点
        Thrnode *pre=NULL;
        Thrnode *Thrt;
        Thrt=new Thrnode;
        Thrt->ltag=0;
        Thrt->rtag=1;
        Thrt->rchild=Thrt;//初始化时，让头结点的右指针指向自己
        if(!r)
            Thrt->lchild=Thrt;    //若为空树，左指针也指回自己
        else
        {
            Thrt->lchild=r;
            pre=Thrt;
            In_Threading(r,pre);    //pre是r的前驱指针
 
            //从上面的函数出来时，pre指在最后一个结点处
            pre->rchild=Thrt;
            pre->rtag=1;
            //最后一个结点的线索化
 
            Thrt->rchild=pre;
        }
        cout<<"二叉树线索化 完成~~"<<endl;
        return Thrt;
    }
    
    void InOrder_Thr(Thrnode *Thrt)    //中序遍历线索二叉树
    {
        //遍历的同时，将相对应的值和结点指针存入结构体，便于搜索
        int count=0;
        Thrnode *r;
        r=Thrt->lchild;
        while(r!=Thrt)
        {
            while(r->ltag==0)
                r=r->lchild;
            cout<<r->data<<"  ";
            ad[count].data=r->data;
            ad[count].p=r;
            count++;
            while(r->rtag==1 && r->rchild!=Thrt)
            {
                r=r->rchild;
                cout<<r->data<<"  ";
                ad[count].data=r->data;
                ad[count].p=r;
                count++;
            }
            r=r->rchild;
        }
    }
 
    Thrnode *Search(int d)    //搜索
    {
        for(int i=0;i<num;i++)
            if(ad[i].data==d)
                return ad[i].p;
    }
 
    void Prior_Thr(Thrnode *Thrt,Thrnode *t,Thrnode *&p)  //求结点前驱
    {
        //p返回结点t的前驱
        p=t->lchild;
        if(p==Thrt)
        {
            cout<<"给定的结点是第一个结点，不存在前驱"<<endl;
            return ;
        }
        if(t->ltag==0)
            while(p->rtag==0)
                p=p->rchild;
    }
 
    void Next_Thr(Thrnode *Thrt,Thrnode *t,Thrnode *&p)    //求结点后继
    {
        p=t->rchild;
        if(p==Thrt)
        {
            cout<<"该结点为最后一个结点，无后继"<<endl;
            return ;
        }
        if(p->rtag==0)
            while(p->ltag==0)
                p=p->lchild;
    }
 
    void Insert_Lchild(Thrnode *Thrt,Thrnode *t,int d)    //作为左孩子插入
    {
        /*
        将结点值为d的结点插入t后面，作为t的左孩子
        如果t本来的无左孩子，那么直接插入即可
        如果t有左孩子，那么：
        t的左孩子在新的节点q插入后，作为q的左孩子，因此q->ltag=0;
        将新结点q作为t的左孩子
        求出新的结点q的前驱，修改q的前驱结点的rchild域，使它的后继为q
        */
        
        Thrnode *q=new Thrnode;
        q->data=d;
        
        q->lchild=t->lchild;
        q->ltag=t->ltag;
        
        q->rchild=t;
        q->rtag=1;
        
        t->lchild=q;
        t->ltag=0;
 
        if(q->ltag==0)
        {
            Thrnode *p;
            Prior_Thr(Thrt,q,p);
            p->rchild=q;
        }
        //若q->rtag为0，那么就要找出q的前继
        cout<<"插入为结点值为："<<t->data<<"的左孩子成功"<<endl;
        num++;
    }
 
    void Insert_Rchild(Thrnode *Thrt,Thrnode *t,int d)    //作为右孩子插入
    {
        //思路和上面的左孩子一样
        Thrnode *q=new Thrnode;
        q->data=d;
        
        q->rchild=t->rchild;
        q->rtag=t->rtag;
 
        q->lchild=t;
        q->ltag=1;
 
        t->rchild=q;
        t->rtag=0;
 
        if(q->rtag==0)
        {
            Thrnode *p;
            Next_Thr(Thrt,q,p);
            p->lchild=q;
        }
        cout<<"插入为结点值："<<t->data<<"的右孩子成功"<<endl;
        num++;
    }
 
};

//t指向头结点，头结点左链lchild指向根结点，头结点右链rchild指向中序遍历的最后一个结点。
//中序遍历二叉线索树表示二叉树t
int InOrderThraverse_Thr(BiTree t)
{
    BiTree p;
    p = t->lchild;                               //p指向根结点
    while(p != t)                               //空树或遍历结束时p == t
    {
        while(p->ltag == Link)                       //当ltag = 0时循环到中序序列的第一个结点
        {
            p = p->lchild;
        }
        printf("%c ", p->data);                      //显示结点数据，可以更改为其他对结点的操作
        while(p->rtag == Thread && p->rchild != t)
        {
            p = p->rchild;
            printf("%c ", p->data);
        }
 
        p = p->rchild;                         //p进入其右子树
    }
 
    return OK;
}

 

说明：


    （1）代码中，p = t->lchild；意思就是上图中的第一步，让p指向根结点开始遍历；
    （2）while(p != t)其实意思就是循环直到图中的第四步出现，此时意味着p指向了头结点，于是与t相等（t是指向头结点的指针），结束循环，否则一直循环下去进行遍历操作；
    （3）while(p-ltag == Link)这个循环，就是由A->B->D->H，此时H结点的ltag不是link（就是不等于0），所以结束此循环；
    （4）然后就是打印H；
    （5）while(p->rtag == Thread && p->rchild != t)，由于结点H的rtag = Thread（就是等于1），且不是指向头结点。因此打印H的后继D，之后因为D的rtag是Link，因此退出循环；
    （6）p=p->rchild；意味着p指向了结点D的右孩子I；
    （7）.....，就这样不断的循环遍历，直到打印出HDIBJEAFCG，结束遍历操作。


    从这段代码可以看出，它等于是一个链表的扫描，所以时间复杂度为O(n)。
    由于充分利用了空指针域的空间（等于节省了空间），又保证了创建时的一次遍历就可以终生受用后继的信息（意味着节省了时间）。所以在实际问题中，如果所用的二叉树需要经过遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。

#include <stdio.h>
#include <stdlib.h>
 
#define ERROR  0
#define OK  1
 
typedef enum{Link, Thread} PointerTag;      //link = 0表示指向左右孩子指针
                                            //Thread = 1表示指向前驱或后继的线索
typedef struct BitNode
{
    char data;                              //结点数据
    struct BitNode *lchild;                 //左右孩子指针
    struct BitNode *rchild; 
    PointerTag ltag;                        //左右标志
    PointerTag rtag;
}BitNode, *BiTree;
 
BiTree pre;                                 //全局变量，始终指向刚刚访问过的结点
 
//前序创建二叉树
void CreateTree(BiTree *t)
{
    char ch;
    scanf("%c", &ch);
     
    if(ch == '#')
    {
        *t = NULL;
    }
    else
    {
        (*t) = (BiTree)malloc(sizeof(BitNode));
        if((*t) == NULL)
        {
            return;
        }
        (*t)->data = ch;
        CreateTree(&((*t)->lchild));
        CreateTree(&((*t)->rchild));
    }
}
 
 
//t指向头结点，头结点左链lchild指向根结点，头结点右链rchild指向中序遍历的最后一个结点。
//中序遍历二叉线索树表示的二叉树t
int InOrderThraverse_Thr(BiTree t)
{
    BiTree p;
    p = t->lchild;           //p指向根结点
    while(p != t)
    {
        while(p->ltag == Link)   //当ltag = 0时循环到中序序列的第一个结点
        {
            p = p->lchild;
        }
        printf("%c ", p->data);  //显示结点数据，可以更改为其他对结点的操作
        while(p->rtag == Thread && p->rchild != t)
        {
            p = p->rchild;
            printf("%c ", p->data);
        }
 
        p = p->rchild;           //p进入其右子树
    }
 
    return OK;
}
 
//中序遍历进行中序线索化
void InThreading(BiTree p)
{
    if(p)
    {
        InThreading(p->lchild);              //递归左子树线索化
        if(!p->lchild)                       //没有左孩子
        {
            p->ltag = Thread;                //前驱线索
            p->lchild = pre;             //左孩子指针指向前驱,这里是第3步
        }
        if(!pre->rchild)                 //没有右孩子
        {
            pre->rtag = Thread;              //后继线索
            pre->rchild = p;             //前驱右孩子指针指向后继(当前结点p)
        }
        pre = p;
 
        InThreading(p->rchild);              //递归右子树线索化
    }
}
//建立头结点，中序线索二叉树
int InOrderThread_Head(BiTree *h, BiTree t)
{
    (*h) = (BiTree)malloc(sizeof(BitNode));
    if((*h) == NULL)
    {
        return ERROR;
    }
 
    (*h)->rchild = *h;
    (*h)->rtag = Link;
 
    if(!t)      //如果为NULL
    {
        (*h)->lchild = *h;
        (*h)->ltag = Link;
    }
    else
    {
        pre = *h;
        (*h)->lchild = t;        //第一步
        (*h)->ltag = Link;
        InThreading(t);         //找到最后一个结点
        pre->rchild = *h;        //第四步
        pre->rtag = Thread;
        (*h)->rchild = pre;      //第二步
    }
}
 
int main(int argc, char **argv)
{
    BiTree t;
    BiTree temp;
 
    printf("请输入前序二叉树的内容:\n");
    CreateTree(&t);                 //建立二叉树
    InOrderThread_Head(&temp, t);       //加入头结点，并线索化
    printf("输出中序二叉树的内容:\n");
    InOrderThraverse_Thr(temp);
     
    printf("\n");
    return 0;
}