线索化二叉树

/*.............................
功能：前序遍历输入二叉树

      中序遍历线索化

      非递归输出

时间：2015-07-16

人员：西瓜太郎

......................*/


#include <stdio.h>
#include <stdlib.h>

typedef char ElementType;
typedef int Status;



typedef enum {
    Link,
    Thread
}PointerTag;
typedef struct BiThrNode
{
    ElementType data;
    struct BiThrNode *lchild, *rchild;
    PointerTag ltag;
    PointerTag rtag;
}BiThrNode, *BiThrTree;

BiThrTree pre;

//先序遍历,初始化

Status InitBiThree(BiThrTree *T)
{
    ElementType c;
    scanf("%c",&c);
    if( ' ' == c)
    {
        (*T) = NULL;
    }
    else
    {
        (*T) = (BiThrNode *)malloc(sizeof(struct BiThrNode));
        if(!(*T))
        {
            return -1;
        }
        else
        {
            (*T)->data = c;
            (*T)->ltag = Link;
            (*T)->rtag = Link;

            InitBiThree(&(*T)->lchild);
            InitBiThree(&(*T)->rchild);
        }
    }
    return 0;
}

//中序遍历线索化
Status InOrderTraverse(BiThrTree T)
{
    if(T)
    {
        InOrderTraverse(T->lchild);

        if(NULL == T->lchild )
        {
            T->lchild = pre;
            T->ltag = Thread;
        }
        if(NULL == pre->rchild)
        {
            pre->rtag = Thread;//T，此处费时间2个小时，找到错误！
            pre->rchild = T;
        }
        pre = T;
        InOrderTraverse(T->rchild);
    }
    return 0;

}

Status InOrderThreading(BiThrTree T, BiThrTree *P)
{
    *P = (BiThrNode *)malloc(sizeof(struct BiThrNode));
    if(!*P)
    {
        return -1;
    }

    (*P)->ltag = Link;
    (*P)->rtag = Thread;
    (*P)->rchild = (*P);

    if(T)
    {
        (*P)->lchild = T;

        pre = *P;

        InOrderTraverse(T);

        //收尾：
        pre->rtag = Thread;
        pre->rchild = *P;

        (*P)->rchild = pre;
    }
    else
    {
        (*P)->lchild = (*P);
    }

    return 0;
}

void InOrderTraverse_Thr(BiThrTree T)//递归遍历  二叉树
{
    if(T)
    {
        InOrderTraverse_Thr(T->lchild);
        printf("%c",T->data);
        InOrderTraverse_Thr(T->rchild);
    }


}

void inOrderTraverse(BiThrTree T)//非递归！中序遍历线索化后的二叉树
{
    BiThrTree p;
    p = T->lchild;
    while( p != T)
    {
        while( Link == p->ltag)
        {
            p = p->lchild;
        }
        printf("%c",p->data);//找到左子树为空的结点。

        while(Thread == p->rtag && T != p->rchild)
        {
            p = p->rchild;
            printf("%c", p->data);
        }

        p = p->rchild;
    }
}

int main()
{
    BiThrTree T=NULL;
    BiThrTree p;
    
    InitBiThree(&T);

    InOrderThreading(T,&p);

    inOrderTraverse(p);

    printf("\n");

    
    return 0;
}