线索二叉树实现（中序）

/* 目的在于让没有孩子的指针标示前驱和后继一次方便遍历 */
/* 首先建立树的头结点，然后若发现没有左孩子，就指向pre标示前驱
，由于中序遍历的特点，回溯的那个结点便是下一个要访问的结点，所
以此时判断pre有无右孩子，若无，则指向当前回溯结点标示下一个要访
问的结点 */
/* 最后完成头结点的右结点工作，完成线索二叉树 */

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

//link（0）指向孩子节点
//thread（1）指向双亲节点

typedef enum{link,thread} pointertag;
typedef char    elemtype;

typedef struct bitthrnode
{
    elemtype    data;
    pointertag  ltag;
    pointertag  rtag;
    struct bitthrnode  *lchild;
    struct bitthrnode  *rchild;
}bitthrnode,*bitthrtree;

bitthrtree  pre;

void treecreat(bitthrtree *T)
{
    elemtype    ch;

    scanf("%c",&ch);
    if( ' ' == ch )
    {
        (*T)=NULL;
        exit(0);
    }
    else
    {
        (*T) = (bitthrnode *)malloc(sizeof(bitthrnode));
        (*T)->data = ch;
        (*T)->ltag = link;
        (*T)->rtag = link;

        treecreat(&(*T)->lchild);
        treecreat(&(*T)->rchild);
    }
}

void visit(bitthrtree T)
{

}

int inorder_threading_init(bitthrtree *thrt, bitthrtree bt)
{
    *thrt = (bitthrtree) malloc (sizeof(bitthrnode));
    if (!*thrt)
        exit(1);
                                                   /* 将头结点线索化 */
    (*thrt)->ltag = link;
    (*thrt)->rtag = thread;
    (*thrt)->rchild = (*thrt);

    if (!bt)
    {                                               /* 若二叉树为空，则将lchild指向自己 */
        (*thrt)->lchild = (*thrt);
    }
    else
    {
        (*thrt)->lchild = bt;                   /* 头结点左指针指向根结点 */
        pre = (*thrt);
        in_threading(bt);                       /* 中序遍历进行中序线索化 */

        //收尾工作，形成双向链表
        pre->rchild = *thrt;
        pre->rtag = thread;
        (*thrt)->rchild = pre;
    }

//中序遍历线索化
void inthreading(bitthrtree T)
{
    if( T )
    {
        //递归调用左结点中序线索化
        inthreading(T->lchild);

        if( !T->lchild )//如果左孩子为空
        {
            T->ltag = thread;
            T->lchild = pre;
        }
        //处理结点
        if( !pre->rchild )
        {
            pre->rtag = thread;
            pre->rchild = T;
        }
        pre = T;

        //递归调用左结点中序线索化
        inthreading(T->rchild);
    }
}

//传入头结点，来一次循环遍历
void inorder_threading(bitthrtree T)
{
    bitthrtree  p;
    p=T->lchild;
    while( p != T )
    {
        while( p->ltag == link )
        {
            p = p->lchild;
        }

        while( p->rchild != T && p->rtag == thread)
        {
            p = p->rchild;
            visit(p);
        }
        p = p->rchild;
    }
}


int main()
{
    //脑补部分
    return 0;
}