扩展的先序遍历序列建立以二叉链表方式存储的二叉树，后序遍历

1． 请根据用户输入的“扩展的先序遍历序列”(用小圆点表示空子树)，建立以二叉链表方式存储的二叉树，然后写出后序遍历该二叉树的非递归算法，并将对应的程序调试运行通过。

#include
#include

#define FALSE 0
#define TRUE 1
#define ERROR 0
#define OK 1
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT  10
typedef int status;

//二叉树的二叉链表存储表示
typedef struct BiTNode{

    struct BiTNode *lchild, *rchild;
    char data;

}BiTNode, * BiTree;

//顺序栈的存储表示
typedef struct SqStack{
    int stacksize;
    BiTree *base;
    BiTree *top;
}SqStack;
status InitStack(SqStack &S)
{
    S.base = (BiTree*)malloc(STACK_INIT_SIZE*sizeof(BiTNode));
    if (!S.base) exit(OVERFLOW);
    S.top = S.base;
    S.stacksize =STACK_INIT_SIZE;
    return OK;
}
status GetTop(SqStack &S,BiTree &p)
{
    //若栈不空，则删除S的栈顶元素，用p返回其值
    if (!S.base) exit(OVERFLOW);
    if (S.base==S.top)return ERROR;
    p = *(S.top-1);
    return OK;
}
status Push(SqStack &S, BiTree T)
{
    //插入元素 T 为新的栈顶元素
    if (S.top - S.base >= S.stacksize)
    {
        S.base = (BiTree*)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(BiTNode));
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    if (!S.base) exit(OVERFLOW);
    (*S.top )= T;
    S.top++;
    return OK;
}
status Pop(SqStack &S, BiTree &p)
{
    //若栈不空，则删除栈顶元素，并用p返回其值
    if (!S.base) exit(OVERFLOW);
    if (S.base == S.top)return ERROR;
    --S.top;
    p =* S.top;
    return OK;
}
status StackEmpty(SqStack S)
{
    //若栈为空，返回TRUE；否则，返回FALSE
    if (!S.base) exit(OVERFLOW);
    if (S.base == S.top)return TRUE;
    else return FALSE;
}
status CreateBiTree(BiTree &T)
{
    //扩展的先序遍历序列(用小圆点表示空子树)，建立以二叉链表为存储结构的二叉树
    char ch;
    printf("Input:");
    ch = getchar();
    getchar();
    if (ch == '.') T = NULL;
    else
    {
        T = (BiTree)malloc(sizeof(BiTNode));
        if (!T) exit(OVERFLOW);
        T->data = ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    return OK;
        /*char ch; 
        ch = getchar(); 
        if (ch == '.')   T = NULL;
        else {
            if (!(T = (BiTree)malloc(sizeof(BiTNode))))
                exit(OVERFLOW); 
                T->data = ch; 
                CreateBiTree(T->lchild); 
                CreateBiTree(T->rchild); 
        }
        return OK;*/
}
status Visit(char e)
{
    //打印e的值
    printf("%c ", e);
    return OK;

}
status PostOrderTraverse(BiTree &T, status(*Visit)(char e))
{
    //采用二叉链表存储结构，Visit是对函数数据元素操作的应用
    //后序遍历二叉树T的非递归算法，对每个数据元素使用函数Visit
    SqStack S;
    BiTree p=T,q=NULL;//q表示刚刚遍历过的节点
    InitStack(S);

    while (p ||! StackEmpty(S))
    {   
        while (p)
        {
            Push(S, p);
            p = p->lchild;
        }
            GetTop(S, p);
            if (p->rchild == NULL || p->rchild== q)
            {
                if (!Visit(p->data))return ERROR;
                q = p;
                Pop(S, p);
                p = NULL;
            }
            else
            {
                p = p->rchild;
            }

    }

    return  OK;
}   
int main()
{
    BiTree T;
    //printf("%d",sizeof(BiTNode));
    CreateBiTree(T);
    printf("PostOrder:");
    PostOrderTraverse(T, Visit);
    printf("\n");
    system("pause");
    return 0;
}