二叉树非递归遍历

上码：

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

template<class T>
struct BiNode {
    T data;
    BiNode<T> *lchild, *rchild;//左子树、右子树
};

template<class T>
class BiTree
{
public:
    BiTree();                                //构造函数，初始化二叉树，前序序列由键盘输入
    ~BiTree();                                //析构函数，释放二叉链表中的各结点的存储空间
    BiNode<T>* Getroot();                    //获得指向根节点的指针
    void PreOrder(BiNode<T>* root);            //前序遍历二叉树
    void InOrder(BiNode<T>* root);            //中序遍历二叉树
    void PostOrder(BiNode<T>* root);        //后序遍历二叉树
    void LeverOrder(BiNode<T>* root);        //层序遍历二叉树

    void NonPreOrder(BiNode<T>* root);
    void NonInOrder(BiNode<T>* root);
    void NonPostOrder(BiNode<T>* root);
private:
    BiNode<T> *root;                        //指向根节点的头指针
    BiNode<T> *Create();                        //有参构造函数调用
    void ReLease(BiNode<T> *root);            //析构函数调用
};
template<class T>
BiTree<T>::BiTree() {
    this->root = Create();                    //创建对象时，构造函数被调用后，调用Great函数进行初始化
}

template<class T>
BiTree<T>::~BiTree() {
    ReLease(root);                            //调用ReLease释放二叉树链表
}

template<class T>
BiNode<T>* BiTree<T>::Getroot() {
    return root;                            //返回根节点地址
}

template<class T>
void BiTree<T>::PreOrder(BiNode<T>* root) {
    if (root == NULL)
        return;
    cout << root->data << " ";
    PreOrder(root->lchild);                    //前序遍历二叉树（根，左，右）
    PreOrder(root->rchild);
}

template<class T>
void BiTree<T>::InOrder(BiNode<T> *root) {
    if (root == NULL)
        return;
    InOrder(root->lchild);                    //中序遍历二叉树（左，根，右）
    cout << root->data << " ";
    InOrder(root->rchild);
}

template<class T>
void BiTree<T>::PostOrder(BiNode<T>* root) {
    if (root == NULL)
        return;
    PostOrder(root->lchild);                //后序遍历二叉树（左，右，根）
    PostOrder(root->rchild);
    cout << root->data << " ";
}

template<class T>
void BiTree<T>::LeverOrder(BiNode<T>* root) {
    BiNode<T> *p;                            //层序遍历
    if (root == NULL)
        return;
    queue<BiNode<T>*> q;        
    q.push(root);
    while (!q.empty()) {
        p = q.front();
        cout << p->data << " ";
        q.pop();
        if (p->lchild != NULL) {
            q.push(p->lchild);
        }
        if (p->rchild != NULL) {
            q.push(p->rchild);
        }
    }
}

template<class T>
BiNode<T>* BiTree<T>::Create() {
    BiNode<T>* root;                        //构造二叉树
    T ch;
    cout << "请输入创建的一颗二叉树的结点数据：" << endl;
    cin >> ch;
    if (ch == "#")
        root = NULL;
    else {
        root = new BiNode<T>;
        root->data = ch;
        root->lchild = Create();
        root->rchild = Create();
    }
    return root;
}

template<class T>
void BiTree<T>::ReLease(BiNode<T>* root) {
    if (root != NULL) {                        //删除二叉树
        ReLease(root->lchild);
        ReLease(root->rchild);
        delete root;
    }
}

template<class T>
void BiTree<T>::NonPreOrder(BiNode<T>* root) {
    if (root == NULL)
        return;
    stack<BiNode<T>*> s;
    BiNode<T> *p = root, *q;
    while (p != NULL || !s.empty())
    {
        if (p != NULL) {
            cout << p->data << ' ';
            s.push(p);
            p = p->lchild;
        }
        else {
            q = s.top();
            s.pop();
            p = q->rchild;
        }
    }
}
template<class T>
void BiTree<T>::NonInOrder(BiNode<T>* root) {
    if (root == NULL)
        return;
    stack<BiNode<T>*> s;
    BiNode<T> *p = root, *q;
    while (!s.empty() || p != NULL)
    {
        while (p != NULL) {
            s.push(p);
            p = p->lchild;
        }
        if (!s.empty()) {
            q = s.top();
            s.pop();
            cout << q->data << ' ';
            p = q->rchild;
        }

    }

}
template<class T>
void BiTree<T>::NonPostOrder(BiNode<T>* root) {
    if (root == NULL)
        return;
    stack<BiNode<T>*> s;
    stack<int> symbol;                    //visit 记录访问的次数0，1，与s栈一一对应
    BiNode<T> *p = root, *q;
    while (!s.empty() || p != NULL)
    {
        while (p != NULL) {
            s.push(p);
            symbol.push(0);                //对应位置入栈 0，表示未经访问
            p = p->lchild;
        }
                                        //栈不空，且栈顶元素未经访问
        if (!s.empty() && !symbol.top()) {
            symbol.pop();
            symbol.push(1);

            q = s.top();
            p = q->rchild;
        }
                                        //栈不空，且栈顶元素已经被访问
        else if (!s.empty() && symbol.top()) {
            //经过循环体 右子树结束
            while (symbol.top()) {        //清空栈中已被访问过的元素，即symbol为 1者
                q = s.top();
                cout << q->data << ' ';
                s.pop();

                symbol.pop();
                if (!symbol.size())
                    break;
            }

            if (!s.empty()) {
                symbol.pop();
                symbol.push(1);

                q = s.top();
                p = q->rchild;
            }
            else {
                p = NULL;
            }
        }
        else
            continue;

    }
}

int main()
{
    BiTree<string> bt;//创建一棵树
    BiNode<string>* root = bt.Getroot();
    cout << "------前序遍历------" << endl;
    bt.PreOrder(root);
    cout << endl;
    cout << "------后序遍历------" << endl;
    bt.PostOrder(root);
    cout << endl;
    cout << "------中序遍历------" << endl;
    bt.InOrder(root);
    cout << endl;
    cout << "------层序遍历------" << endl;
    bt.LeverOrder(root);
    cout << endl;
    cout << "---非递归前序遍历---" << endl;
    bt.NonPreOrder(root);
    cout << endl;
    cout << "---非递归后序遍历---" << endl;
    bt.NonPostOrder(root);
    cout << endl;
    cout << "---非递归中序遍历---" << endl;
    bt.NonInOrder(root);
    cout << endl;
    return 0;
}

后序遍历有点蹩脚，需要注意几点细节，避免死循环陷阱。