数据结构之树之线索化二叉树

#include<iostream>
#include<malloc.h>
#include<stdlib.h>
using namespace std;

typedef char ElemTypeTree;
const int Link = 0;//0时为指针
const int Thread = 1;//1时为线索

typedef struct Node
{
    int ltag, rtag;
    ElemTypeTree data;
    struct Node *lchild, *rchild;
}*BiTree,BiTNode;
BiTree pre = NULL;

typedef struct
{
    BiTree *basequeue;
    int front;
    int rear;
    int queuesize;
}Queue;
typedef struct
{
    BiTree *basestack;
    int top;
    int bottom;
    int stacksize;
}Stack;
void CreateTree(BiTree &T)
{
    BiTree root;
    char ch;
    ch = getchar();
    if ('#' == ch)
        T = NULL;
    else
    {
        root = (BiTree)malloc(sizeof(BiTNode));
        T = root;
        root->data = ch;
        CreateTree(root->lchild);
        CreateTree(root->rchild);
    }
}

void InitQueue(Queue &ptr)
{
    ptr.queuesize = 10;
    ptr.basequeue = (BiTree *)malloc(ptr.queuesize * sizeof(BiTree));
    ptr.front = 0;
    ptr.rear = -1;
}

void EnQueue(Queue &ptr, BiTree T)
{
    if (ptr.rear - ptr.front == ptr.queuesize)
    {
        ptr.basequeue = (BiTree *)realloc(ptr.basequeue, 2 * ptr.queuesize * sizeof(BiTree));
        ptr.queuesize *= 2;
    }
    ptr.basequeue[++ptr.rear] = T;
}

void DeQueue(Queue &ptr, BiTree &T)
{
    if (ptr.rear == -1||ptr.front>ptr.rear)
    {
        cout << "error" << endl;
        T = NULL;
    }
    else
    {
        T = ptr.basequeue[ptr.front];
        ptr.front++;
    }
}
int EmptyQueue(Queue Q)
{
    if (Q.rear == -1||Q.front>Q.rear)
        return 1;
    else
        return 0;
}

void InitStack(Stack &ptr)
{
    ptr.stacksize = 10;
    ptr.basestack = (BiTree *)malloc(sizeof(BiTree));
    ptr.top = -1;
    ptr.bottom = 0;
}
void EnStack(Stack &ptr, BiTree T)
{
    if (ptr.top - ptr.bottom == ptr.stacksize)
    {
        ptr.basestack = (BiTree *)realloc(ptr.basestack, 2 * ptr.stacksize * sizeof(BiTree));
        ptr.stacksize *= 2;
    }
    ptr.basestack[++ptr.top] = T;
}

void DeStack(Stack &ptr, BiTree &T)
{
    if (ptr.top == -1)
    {
        cout << "error" << endl;
        return;
    }
    else
    {
        T = ptr.basestack[ptr.top--];
    }
}

void Bianli(BiTree T)
{
    Queue Q;
    BiTree temp = NULL;
    InitQueue(Q);
    if (T)
    {
        EnQueue(Q,T);
        while (!EmptyQueue(Q))
        {
            DeQueue(Q, temp);
            if (temp!=NULL)
                cout << temp->data << endl;
            else
                return;
            if(temp->lchild) EnQueue(Q, temp->lchild);
            if(temp->rchild) EnQueue(Q, temp->rchild);
        }
    }
}
int EmptyStack(Stack S)
{
    if (S.top < S.bottom)
        return 1;
    else
        return 0;
}
void Visit(BiTree t)
{
    if (NULL == t)
    {
        cout << "error" << endl;
        return;
    }
    else
        cout << t->data << endl;
}
void nodiguiInorederTraver(BiTree T)
{
    BiTree p=T;
    Stack S;
    InitStack(S);
    while (p || !EmptyStack(S))
    {
        if (p)
        {
            EnStack(S, p);
            p = p->lchild;
        }
        else
        {
            DeStack(S, p);
            Visit(p);
            p = p->rchild;
        }
    }

}

void InThreading(BiTree p)
{
    if (p)
    {
        InThreading(p->lchild);
        if (!p->lchild)
        {
            p->ltag = Thread;
            p->lchild = pre;
        }
        else
            p->ltag = Link;
        if (!pre->rchild)
        {
            pre->rtag = Thread;
            pre->rchild = p;
        }
        else
            pre->rtag = Link;
        pre = p;
        InThreading(p->rchild);
    }
}

void InOrderThreading(BiTree &Thrt, BiTree T)
{
    if (!(Thrt = (BiTree)malloc(sizeof(BiTNode))))
        return;
    Thrt->ltag = Link;
    Thrt->rtag = Thread;
    Thrt->rchild = Thrt;
    if (!T)
        Thrt->lchild = Thrt;
    else
    {
        Thrt->lchild = T;
        pre = Thrt;
        InThreading(T);
        pre->rchild = Thrt;
        pre->rtag = Thread;
        Thrt->rchild = pre;

    }

}

void InOrderTraverse(BiTree T)
{
    BiTree p = NULL;
    p = T->lchild;
    while (p != T)
    {
        while (p->ltag == Link)
            p = p->lchild;
        Visit(p);
        while (p->rtag == Thread && p->rchild != T)
        {
            p = p->rchild;
            Visit(p);
        }
        p = p->rchild;
    }

}

int main()
{
    BiTree head = NULL, T = NULL;
    CreateTree(T);
    InOrderThreading(head, T);
    InOrderTraverse(head);
    //cout << "bianli" << endl;
    //Bianli(T);
    //cout << "houxu" << endl;
    //nodiguiInorederTraver(T);
    //    cout << "线索化" << endl;
    //InorderTreading(head,T);
    //InOrderTraverseThr(head);

    //return 0;
    return 0;
}