二叉树递归与非递归遍历

#include<iostream>
#include<stack>
#define STACKINITSIZE 20//栈初始空间大小
#define INCREASEMENT 10//栈空间大小的增量
using namespace std;
typedef struct BiTNode {
    char data;
    struct BiTNode* lchild, * rchild;
    int count = 0;
}BiTNode, * BiTree;
typedef struct SqStack
{
    BiTNode* base;
    BiTNode* top;
    int stacksize;
}SqStack;
int Push(SqStack& S, BiTNode e)
{
    if (S.top - S.base >= S.stacksize)
    {
        S.base = (BiTNode*)malloc((STACKINITSIZE + INCREASEMENT) * sizeof(BiTNode));
        if (!S.base)
            return 0;
        S.stacksize = 30;
    }
    *(S.top - 1) = e;
    S.top++;
    return 1;
}

int Pop(SqStack& S, BiTNode& e)
{
    if (S.base == S.top)
        return 0;
    S.top--;
    e = *S.top;
    return 1;
}

int InitStack(SqStack& S)
{
    S.base = (BiTNode*)malloc(100 * sizeof(BiTNode));//20为栈的大小，可以更改
    if (!S.base)
        return 0;
    S.top = S.base;
    S.stacksize = 100;
    return 1;
}

bool StackEmpty(SqStack S)
{
    if (S.base == S.top)
        return true;
    else
        return false;
}
int PreOrderTraverse(BiTree T) {
    if (T) {
        cout << " " << T->data;
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
    else
        return 0;
}
void InOrder(BiTree T) {
    if (T) {
        InOrder(T->lchild);
        cout << " " << T->data;
        InOrder(T->rchild);
    }
}
void PostOrder(BiTree T) {
    if (T) {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        cout << " " << T->data;
    }
}
int CreateBiTree(BiTree& T) {
    char ch;
    cin >> ch;
    if (ch == '.')T = NULL;
    else {
        if (!(T = (BiTNode*)malloc(sizeof(BiTNode))))exit(OVERFLOW);
        T->data = ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    return 0;
}
//非递归中序遍历
void InOrder2(BiTree T) {

    stack<BiTree> s;

    BiTree p = T;

    while (p || !s.empty())
    {
        while (p)//压入左子树结点
        {
            s.push(p);
            p = p->lchild;
        }

        p = s.top();
        cout << p->data << " ";
        s.pop();
        p = p->rchild;
    }

}
void PostOrder2(BiTree T) {
    stack<BiTree> s;

    BiTree p = T;
    BiTree flag = NULL;
    while (p || !s.empty())
    {
        while (p)//压入左子树结点
        {
            s.push(p);
            p = p->lchild;
        }

        p = s.top();
        if (p->rchild && flag != p->rchild)
            p = p->rchild;
        else if (p->rchild == NULL || flag == p->rchild) {
            cout << p->data << " ";
            flag = p;
            s.pop();
            p = NULL;
        }
    }
}
void PostOrder3(BiTree T) {
    stack<BiTree>s;
    BiTree p = T;
    while (p || !s.empty()) {
        while (p) {
            p->count = 1;
            s.push(p);
            p=p->lchild;
            
        }
        if (s.top()) 
            p = s.top();
            s.pop();
        if ((p->count )== 1) {
            p->count++;
            s.push(p);
            p = p->rchild;
        }
        else if (p->count == 2)
        {
            cout << p->data << " ";
            p = NULL;
        }
    }
}

/*void PostOrder2(BiTree T) {
    SqStack S;
    BiTree p;
    p = T;
    InitStack(S);
    while (p || !isEmpty(S)) {
        if (p) {
            Push(S,p)
        }
    }
}*/
int main() {
    BiTree T;
    CreateBiTree(T);
    int order;
    cout << "先序" << endl;
    PreOrderTraverse(T);
    cout << endl;
    cout << "中序" << endl;
    InOrder(T);
    cout << endl;
    cout << "后序" << endl;
    PostOrder(T);
    cout << endl;
    cout << "非递归中序遍历" << endl;
    InOrder2(T);
    cout << endl;
    cout << "非递归后序遍历" << endl;
    PostOrder2(T);
    cout << endl;
    cout << "非递归后序遍历" << endl;
    PostOrder3(T);
    cout << endl;
}