不使用递归,使用堆栈C++完成二叉树的遍历

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

//以下是ADT
#ifndef _Traversal_H
typedef int ElementType;
typedef struct Node *PtrToNode;
typedef PtrToNode Position;
typedef PtrToNode BinTree;
struct Node {
    ElementType Data;
    PtrToNode Left, Right;
    bool isFinished=false;
};

void PreOrderTraversal(BinTree T);
void InOrderTraversal(BinTree T);
void PostOrderTraversal(BinTree T);
void LevelOrderTraversal(BinTree T);


#endif // !_Traversal_H

// 具体的实现
static BinTree Create(ElementType X) {
    BinTree T;
    T = (BinTree)malloc(sizeof(struct Node));
    T->Data = X;
    T->Left = T->Right = NULL;
    T->isFinished = false;
    return T;
}

static void Print(BinTree BT) {
    if (BT) {
        Print(BT->Left);
        /* 此处假设对BT结点的访问就是打印数据 */
        printf("%d ", BT->Data); /* 假设数据为整型 */
        Print(BT->Right);
    }
}

BinTree BuildeAnTempleTree() {
    BinTree T;
    queue<int> dataSource;
    queue<Position> PositionContainer;
    for (int i = 1; i <= 9; i++)
        dataSource.push(i);
    int tmp;
    tmp = dataSource.front();
    T = Create(tmp);
    PositionContainer.push(T);
    dataSource.pop();

    while (!dataSource.empty())
    {
        tmp = dataSource.front();
        dataSource.pop();
        Position p = PositionContainer.front();
        PositionContainer.pop();

        p->Left = Create(tmp);
        PositionContainer.push(p->Left);

        if (!dataSource.empty()) {
            tmp = dataSource.front();
            dataSource.pop();
            p->Right = Create(tmp);
            PositionContainer.push(p->Right);
        }
    }

    return T;
}
static void PrintPosition(Position P)
{

    cout << P->Data << " ";
}
//层序遍历
void LevelOrderTraversal(BinTree T) {
    queue<Position> Q;
    if (!T)
        return;
    Position P = T;
    Q.push(P);
    while (!Q.empty())
    {
        P = Q.front();
        Q.pop();

        PrintPosition(P);
        if (P->Left) Q.push(P->Left);
        if (P->Right) Q.push(P->Right);
    }

}

//使用队列的先序遍历
void PreOrderTraversal(BinTree T) {
    stack<Position> sta;
    Position P = T;
    while (P || !sta.empty())
    {
        if (P)
        {
            PrintPosition(P);
            sta.push(P);
            P = P->Left;
        }
        else
        {
            P = sta.top();
            sta.pop();
            if (P) {
                P = P->Right;
            }
        }
    }
    cout << endl;
}
//中序遍历
void InOrderTraversal(BinTree T)
{
    stack<Position> sta;
    Position P=T;

    while (P || !sta.empty())
    {
        if (P)
        {
            sta.push(P);
            P = P->Left;
        }
        else
        {
            P = sta.top();
            sta.pop();
            if (P)
            {
                PrintPosition(P);
                P = P->Right;
            }
        }
    }
    cout << endl;
}

//后序遍历
void PostOrderTraversal(BinTree T)
{
    stack<Position> sta;
    Position P = T;

    while (P || !sta.empty())
    {
        if (P)
        {
            sta.push(P);
            P = P->Left;
        }
        else
        {
            P = sta.top();
            if (!P->Right || P->Right->isFinished)//右子没有或者已经被访问过就应该可以访问了
            {
                PrintPosition(P);
                P->isFinished = true;
                sta.pop();
                P = NULL;//返回过的东西置空
            }
            else {
                P = P->Right;
            }
        }
    }
    cout << endl;
}

int main() {
    BinTree T = BuildeAnTempleTree();
    LevelOrderTraversal(T);
    cout <<"前序:"<< endl;
    PreOrderTraversal(T);
    cout << "中序:" << endl;
    InOrderTraversal(T);
    cout << "后序:" << endl;
    PostOrderTraversal(T);
    cin.get();
    return 0;
}