前序线索化二叉树

 

#include <iostream>
using namespace std;
enum PointerTag {Link,Thread};    //Link非线索标记,Thread线索标记
typedef struct node
{
    
    char data;
    struct node *rchild;
    struct node *lchild;
    PointerTag  Ltag,Rtag;    //左右标志
}BiTNode,*BiTree;
BiTree pre;                   //全局变量，用于二叉树的线索化

//创建二叉树
void Creat(BiTree &T)
{
    char ch;
    ch=getchar();
    if('#'==ch)
        T=NULL;
    else
    {
        T=(BiTree )malloc(sizeof(BiTNode));
        T->data=ch;
        T->Ltag=Link;
        T->Rtag=Link;
        Creat(T->lchild);
        Creat(T->rchild);
    }
}
//前序遍历二叉树
void Traverse(BiTree &rt)
{
    if(rt!=NULL)
    {
        cout<<rt->data<<"  ";
        Traverse(rt->lchild);
        Traverse(rt->rchild);
    }
}

//前序线索化二叉树
void preThreading(BiTree &p)
{
    if(p)
    {

        if(!p->lchild)
        {
            p->Ltag=Thread;
            p->lchild=pre;        //前继线索
        }
        if(!pre->rchild)
        {
            pre->Rtag=Thread;
            pre->rchild=p;        //后继线索
        }
        pre=p;
        if(Link==p->Ltag)
        {
            preThreading(p->lchild);
        }
        if(Link==p->Rtag)
        {
            preThreading(p->rchild);
        }
    }
}
BiTree preorderThreading(BiTree &T)
{
    BiTree Thrt;
    if(!(Thrt = (BiTree) malloc (sizeof(BiTNode))))
    {
        exit(1);
    }
    Thrt->Ltag=Link;
    Thrt->Rtag=Thread;
    Thrt->rchild=Thrt;    //右指针回指
    if(!T)
    {
        Thrt->lchild=Thrt;    //若二叉树空，则左指针回指
    }
    else
    {
        Thrt->lchild=T;
        pre=Thrt;
        
        preThreading(T);        //前序遍历进行中序线索化
        
        pre->rchild=Thrt;        //最后一个节点处理
        pre->Rtag=Thread;
        Thrt->rchild=pre;
    }
    return Thrt;
}


//前序遍历线索二叉树
void preorderTraver(BiTree &thrt)
{
    BiTree p;
    p=thrt->lchild;
    while(p!=thrt)
    {
        cout<<p->data<<"  ";
        if(Link==p->Ltag)
        {
            p=p->lchild;
        }
        else
        {
            p=p->rchild;
        }
    }
}

int main()
{
    BiTree root;
    Creat(root);        //创建二叉树
    
    //前序遍历二叉树
    cout<<"前序遍历序列是:"<<endl;
    Traverse(root);
    cout<<endl;
    
    BiTree Thrt;
    Thrt=preorderThreading(root);
    preorderTraver(Thrt);
    cout<<endl;
    return 0;
}