非递归遍历二叉树

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

using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW 0
#define TRUE 1
#define FALSE 0


typedef char TElemType;
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode *lchild,*rchild;
} BiTNode,*BiTree;


typedef BiTree sElemType;
typedef int Status;
typedef struct StackNode
{
    sElemType data;
    struct StackNode *next;
} StackNode,*LinkStackPtr;

typedef struct LinkStack
{
    LinkStackPtr top;
    int sum;
} LinkStack;

//栈空
Status StackEmpty(LinkStack *S)
{
    if(S->sum == 0)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
//入栈
Status Push(LinkStack *S,sElemType e)
{
    LinkStackPtr ls = (LinkStackPtr)malloc(sizeof(StackNode));
    ls->data = e;
    ls->next = S->top;
    S->top = ls;
    S->sum++;
    return OK;
}
//出栈
Status Pop(LinkStack *S,sElemType &e)
{
    if(StackEmpty(S))
    {
        cout<<"栈空"<<endl;
        return ERROR;
    }
    LinkStackPtr p = S->top;
    S->top = p->next;
    e = p->data;
    free(p);
    S->sum--;
    return OK;
}
//获取栈顶元素
Status GetTop(LinkStack *S,sElemType &e)
{
    if(StackEmpty(S))
    {
        cout<<"栈空"<<endl;
        return ERROR;
    }
    LinkStackPtr p = S->top;
    e = p->data;
    free(p);
    return OK;
}

Status init_BiTree(BiTree &T)
{
    T = (BiTree)malloc(sizeof(BiTNode));
    if(!T)
    {
        exit(OVERFLOW);
    }
    return OK;
}

Status CreateBiTree(BiTree &T)
{
    BiTree b = (BiTree)malloc(sizeof(BiTNode));
    char ch = cin.get();
    if(ch == ' ')
    {
        cout<<"NUll"<<endl;
        T = NULL;
    }
    else
    {
        cout<<"再次输入-------------"<<endl;
        if(!(T=(BiTree)malloc(sizeof(BiTNode))))
        {
            exit(OVERFLOW);
        }
        T ->data = ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    return OK;
}
//中序遍历 循环：（向左走到尽头，弹出空结点后，取栈顶元素数据，然后将其右孩子压入栈）
Status InOrderTraverse (BiTree T,Status (*Visit)(TElemType e))
{
    LinkStack *S ;

    S=(LinkStack*)malloc(sizeof(LinkStack));
    S->sum=0;
    Push(S,T);
    BiTree p;

    while(!StackEmpty(S))
    {

        while(GetTop(S,p)&&p)
        {

            Push(S,p->lchild);//向左走到尽头
        }

        Pop(S,p);

        if(!StackEmpty(S))
        {

            Pop(S,p);

            if(!Visit(p->data))
            {

                return ERROR;
            }

            Push(S,p->rchild);
        }
    }
    return OK;
}
//前序遍历
Status PreOrderTraverse (BiTree T,Status (*Visit)(TElemType e))
{
    LinkStack *S ;
    //InitStack(S);
    S=(LinkStack*)malloc(sizeof(LinkStack));
    S->sum=0;
    Push(S,T);
    BiTree p;

    while(!StackEmpty(S))
    {

        while(GetTop(S,p)&&p)
        {
            if(!Visit(p->data))
            {

                return ERROR;
            }

            Push(S,p->lchild);//向左走到尽头
        }

        Pop(S,p);//弹出空结点

        if(!StackEmpty(S))
        {

            Pop(S,p);//弹出左兄弟结点
            Pop(S,p);//弹出双亲

            Push(S,p->rchild);//右兄弟结点压入栈中
        }
    }
    return OK;
}
//后续遍历
Status PostOrderTraverse(BiTree T,Status(*Visit)(TElemType e))
{
    LinkStack *S;
    S = (LinkStack*)malloc(sizeof(LinkStack));
    S->sum = 0;
    BiTree p;//当前结点
    BiTree pLastVisit;//记录上次访问的结点
    Push(S,T);
    while(GetTop(S,p)&&p)
    {
        Push(S,p->lchild);//向左走到尽头
    }
    Pop(S,p);//弹出空结点
    while(!StackEmpty(S))
    {
        Pop(S,p);

        if(p)
        {
            //如果没有右子树或右子树已经访问过（输出结点包含的数值），再访问该结点数
            if(p->rchild == NULL||p->rchild==pLastVisit)
            {
                if(!Visit(p->data))
                {
                    return ERROR;
                }
                pLastVisit = p;
            }
            //如果有右子树且没有访问过，右结点入栈，同时向左走到尽头
            else
            {
                Push(S,p);
                p = p->rchild;
                while(p)
                {

                    Push(S,p);
                    p = p->lchild;
                }
            }
        }
    }
}
Status Visit(TElemType e)
{

    if(e ==NULL)
    {

        return ERROR;
    }
    cout<<e<<"--";
    return OK;
}



int main()
{
    BiTree T;
    CreateBiTree(T);
    cout<<"输入完毕"<<endl;
    PostOrderTraverse(T,Visit);


}