数据结构——后序线索化二叉树

#include <iostream>
using namespace std;
typedef enum PointerTag {Link,Thread};    //Link==0,Thread==1;线索
typedef struct treenode
{
    struct treenode *left;
    char            data;
    struct treenode *right;
    PointerTag        Ltag,Rtag;    //左右标志
}Treenode,* Treep;
Treep pre;                   /*全局变量，用于二叉树的线索化*/ 
//初始化二叉树
void init_tree(Treep &root)
{
    root=NULL;
    cout<<"初始化成功!"<<endl;
}
//创建二叉树
void creat_tree(Treep &rt)
{
    char ch;
    ch=getchar();
    if('#'==ch)
        rt=NULL;
    else
    {
        rt=(Treep )malloc(sizeof(Treenode));
        rt->data=ch;
        rt->Ltag=Link;
        rt->Rtag=Link;
        creat_tree(rt->left);        //构造左子树
        creat_tree(rt->right);    //构造右子树    
    }
}
//前序遍历二叉树
void pre_order(Treep &rt)
{
    if(rt!=NULL)
    {
        cout<<rt->data<<"  ";
        pre_order(rt->left);
        pre_order(rt->right);
    }
}

//后序线索化二叉树
void backThreading(Treep &p)
{
    if(p)
    {
        backThreading(p->left);
        backThreading(p->right);
        
        if(!p->left)
        {
            p->Ltag=Thread;
            p->left=pre;        //前继线索
        }
        if(!pre->right)
        {
            pre->Rtag=Thread;
            pre->right=p;        //后继线索
        }

        pre=p;
    }
}//InThreading
Treep backorderThreading(Treep &rt)
{
    Treep thrt;
    if(    !(thrt = (Treep) malloc (sizeof(Treenode) ) ) )
        exit(1);
    thrt->Ltag=Link;
    thrt->Rtag=Thread;    //建头结点
    thrt->right=thrt;    //右指针回指
    if(!rt)
        thrt->left=thrt;    //若二叉树空，则左指针回指
    else
    {
        thrt->left=rt;
        pre=thrt;

        backThreading(rt);        //前序遍历进行中序线索化

        thrt->right=pre;        //最后一个节点处理
    }
    return thrt;
}

Treep parent(Treep &thrt,Treep    &p)
{
    Treep    temp;
    temp=thrt;
    if(temp->left==p)
        return temp;    //父节点是头结点
    else
    {    
        temp=temp->left;
        while( temp->left!=p && temp->right!=p )
        {
            if(Link==temp->Rtag)
                temp=temp->right;    //如果节点有右节点，那么往右
            else
                temp=temp->left;    //如果节点没有右孩子，那么去左孩子，没有左孩子，去前驱，也是走往左
        }
        return temp;
    }
}
//后序遍历线索二叉树
void backorderTraver(Treep &thrt)
{
    Treep    p;
    Treep    par;
    p=thrt->left;
    while(1)
    {
        while(Link==p->Ltag)
            p=p->left;
        if(Link==p->Rtag)
            p=p->right;
        else
            break;        //p指向第一个被访问的节点
    }
    while(p!=thrt)
    {
        cout<<p->data<<"  ";
        par=parent(thrt,p);    //parent是p的双亲:
        
        if(thrt==par)        //1.若parent是thrt，即p是根节点，则无后继
            p=thrt;
        else if(p==par->right || Thread==par->Rtag)    //2.若p是双亲的右孩子，或者是独生左孩子，则后继为双亲
            p=par;
        else
        {
            while(par->Rtag==Link)        //3.若p是有兄弟的左孩子，则后继为双亲的右子树上按照后续遍历访问的第一个节点。
            {
                par=par->right;
                while(par->Ltag==Link)
                {
                    par=par->left;
                }
            }
            p=par;
        }
    }
}

int main()
{
    Treep root;
    init_tree(root);        //初始化树
    cout<<"请输入二叉树,空值以#代表，输完要以Ctrl+Z表示结束，否则影响下个树的创建!:"<<endl;
    creat_tree(root);        //创建二叉树

    //后序遍历二叉树
    cout<<"前序遍历序列是:"<<endl;
    pre_order(root);
    cout<<endl;

    Treep thrt;
    thrt=backorderThreading(root);    //建立后序线索二叉树
    backorderTraver(thrt);            //后序遍历二叉树
    cout<<endl;
    return 0;
}