非递归遍历便利二叉树

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

struct TreeNode
{
    TreeNode* lChild;
    TreeNode* rChild;
    int m_iData;
    TreeNode()
    {
        lChild = NULL;
        rChild = NULL;
        m_iData = 0;
    }
};

/*
递归实现前序遍历
*/
void PreOrder1(TreeNode* root)
{
    if (root == NULL)
    {
        return ;
    }
    cout << "Data: " << root->m_iData << endl;
    PreOrder1(root->lChild);
    PreOrder1(root->rChild);
}
/*
非递归，用栈实现
1. 访问结点p之后，把p入栈，（是为了访问完左边，可以把这个根结点出栈来访问右结点)
2. 判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);
若不为空，则将P的左孩子置为当前的结点P;
3. 直到P为NULL并且栈为空，则遍历结束。
*/
void PreOrder2(TreeNode* root)
{
    stack<TreeNode*> S;
    TreeNode* p = root;
    while (p != NULL || !S.empty())
    {
        while (p != NULL)
        {
            cout << "Data: " << p->m_iData << endl;
            S.push(p);
            p = p->lChild;
        }
        if (!S.empty())
        {
            p = S.top();
            S.pop();
            p = p->rChild;
        }
    }
}
/*
递归中序遍历
*/
void InOrder1(TreeNode* root)
{
    if (root != NULL)
    {
        InOrder1(root->lChild);
        cout << "Data: " << root->m_iData << endl;
        InOrder1(root->rChild);
    }
}
/*
1. 若左孩子不为空，则将p入栈并将p的左孩子置为当前的p，然后对当前的p进行相同的处理
2. 若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶元素，然后将当前的p置为栈顶的右孩子
3. 直到p为NULL并且栈为空则遍历结束
*/
void InOrder2(TreeNode* root)
{
    stack<TreeNode*> S;
    TreeNode* p = root;
    while (p != NULL || !S.empty())
    {
        while (p != NULL)
        {
            S.push(p);
            p = p->lChild;
        }
        if (!S.empty())
        {
            p = S.top();
            S.pop();
            cout << "Data: " << p->m_iData << endl;
            p = p->rChild;
        }
    }

}
/*
递归后序遍历
*/
void PostOrder1(TreeNode* root)
{
    if (root != NULL)
    {
        PostOrder1(root->lChild);
        PostOrder1(root->rChild);
        cout << "Data: " << root->m_iData << endl;
    }
}
/*
非递归实现：
思路是这样的：
当访问一个结点的时候，只有没有左结点也没有右结点或者都访问了的时候，才可以访问。
*/
void PostOrder2(TreeNode* root)
{
    stack<TreeNode*> S;
    TreeNode* cur = NULL;
    TreeNode* pre = NULL;
    S.push(root);
    while (p != NULL || !S.empty())
    {
        cur = S.top();
        if ((cur->lChild == NULL && cur->rChild == NULL)
            || (pre != NULL && (pre == cur->lChild || pre == cur->rChild)))
        {
            cout << "Data: " << cur->m_iData << endl;
            S.pop();
            pre = cur;
        }
        else
        {
            if (cur->rChild != NULL)
            {
                S.push(cur->rChild);
            }
            if (cur->lChild != NULL)
            {
                S.push(cur->lChild);
            }
        }

    }

}
int main()
{

    return 0;
}