二叉树的非递归遍历（栈）

二叉树递归遍历很简单，如先序遍历：

void preOrder(Tree T)
{
    if (T!=NULL)
    {
        cout<<T->element<<" ";
        preOrder(T->left);
        preOrder(T->right);
    }
}

递归过程很简单，可以从二叉树的图结构看出，T一直左走，直到null，然后返回父节点，以其右子节点为根，重复步骤。

因此，需要有个方法，能够返回当前节点的父节点，即能够回溯。

有两种方法：方法见此博客

1.使用栈的记忆：

两个版本：模拟递归的实现效果；模拟后序遍历入栈。

2.增加一个指向父节点的指针。

其中，本文主要用栈结构实现非递归遍历。

其中，由于前序与中序遍历的情况，有节点序列的连续，因此，采用模拟递归的方法较容易；而后序遍历根节点有一定的跳跃性，需要先访问左，然后跳至右节点，最后才访问中间节点，使用模拟后序入栈的顺序遍历方法时，需要一个变量来标记中间节点的访问。

前序遍历与中序遍历的模拟递归实现：

#include <stack>
//前序遍历二叉搜索树：用栈模拟递归
void PreOrderTraversal(Tree T)
{
    stack<Tree> s;
    while (NULL!=T || !(s.size()==0))
    {
        if (T!=NULL)
        {
            cout<<T->element<<" ";//前序遍历，先处理根节点
            s.push(T);//入栈
            T=T->left;//一直向左搜索，若非空则入栈
        }
        else
        {
            T = s.top();//回溯到父节点
            s.pop();
            T = T->right;//以父节点的右子节点为新的根节点，重复上述一直向左搜索操作
        }
    }
    cout<<endl;
}

void InOrderTraversal(Tree T)
{
    stack<Tree> s;
    while(T!=NULL || !s.empty())
    {
        if (T!=NULL)
        {
            s.push(T);
            T=T->left;
        }
        else
        {
            T = s.top();
            s.pop();
            cout<<T->element<<" ";
            T=T->right;
        }
    }
    cout<<endl;
}

后序遍历的非递归模拟后序入栈顺序实现：

//后序遍历二叉搜索树：非递归方法，使用栈（模拟后序）
void PostOrderTraversal(Tree T)
{
    if (NULL==T)
    {
        cout<<"NULL trees"<<endl;
    }
    stack<Tree> s;
    T->bPushed = false;//bPushed:表示左右子节点是否已经入栈。
                       //初始化为false，表示还未处理左右子节点
    s.push(T);

    while (!s.empty())
    {
        T = s.top();
        s.pop();
        if (T->bPushed==true)
        {//bPushed:为true，表示左右子节点均已入栈。此时，访问该节点。
         //bPushed的使用可避免左右子节点重复入栈：false，表示左右子节点需入栈；true的话，直接跳过
            cout<<T->element<<" ";
        }
        else
        {//bPushed:为false。此时，需设置bPushed为true，然后处理左右子节点。
            T->bPushed = true;//设置该节点标志符为true，然后处理左右子节点。
            s.push(T);

            if (T->right!=NULL )
            {
                T->right->bPushed = false;//初始化当前节点的右节点（若存在）为false
                s.push(T->right);
            }

            if (T->left!=NULL )
            {
                T->left->bPushed = false;//初始化当前节点的左节点（若存在）为false
                s.push(T->left);
            }

        }
    }
    cout<<endl;
}

完整程序：

typedef struct TreeNode * Tree;
typedef int ElemType;
struct TreeNode
{
    ElemType element;
    Tree left;
    Tree right;
    bool bPushed;
};
#include <iostream>
using namespace std;


//创建一个空树
Tree MakeEmpty(Tree T)
{
    if (NULL!=T)
    {
        MakeEmpty(T->left);
        MakeEmpty(T->right);
        free(T);
    }
    return NULL;
}

Tree Insert(ElemType X,Tree& T)
{
    if (NULL==T)
    {
        T = (Tree)malloc(sizeof(TreeNode));
        if (NULL==T)
        {
            cout<<"out of space!"<<endl;
        }
        else
        {
            T->element = X;
            T->left=NULL;
            T->right=NULL;
        }
        return T;
    }
    else
    {
        if (X<T->element)
        {
            T->left = Insert(X,T->left);
        }
        else
            T->right = Insert(X,T->right);
    }
    return T;
}

#include <stack>
//前序遍历二叉搜索树：用栈模拟递归
void PreOrderTraversal(Tree T)
{
    stack<Tree> s;
    while (NULL!=T || !(s.size()==0))
    {
        if (T!=NULL)
        {
            cout<<T->element<<" ";//前序遍历，先处理根节点
            s.push(T);//入栈
            T=T->left;//一直向左搜索，若非空则入栈
        }
        else
        {
            T = s.top();//回溯到父节点
            s.pop();
            T = T->right;//以父节点的右子节点为新的根节点，重复上述一直向左搜索操作
        }
    }
    cout<<endl;
}

void InOrderTraversal(Tree T)
{
    stack<Tree> s;
    while(T!=NULL || !s.empty())
    {
        if (T!=NULL)
        {
            s.push(T);
            T=T->left;
        }
        else
        {
            T = s.top();
            s.pop();
            cout<<T->element<<" ";
            T=T->right;
        }
    }
    cout<<endl;
}

//后序遍历二叉搜索树：非递归方法，使用栈（模拟后序）
void PostOrderTraversal(Tree T)
{
    if (NULL==T)
    {
        cout<<"NULL trees"<<endl;
    }
    stack<Tree> s;
    T->bPushed = false;//bPushed:表示左右子节点是否已经入栈。
                       //初始化为false，表示还未处理左右子节点
    s.push(T);

    while (!s.empty())
    {
        T = s.top();
        s.pop();
        if (T->bPushed==true)
        {//bPushed:为true，表示左右子节点均已入栈。此时，访问该节点。
         //bPushed的使用可避免左右子节点重复入栈：false，表示左右子节点需入栈；true的话，直接跳过
            cout<<T->element<<" ";
        }
        else
        {//bPushed:为false。此时，需设置bPushed为true，然后处理左右子节点。
            T->bPushed = true;//设置该节点标志符为true，然后处理左右子节点。
            s.push(T);

            if (T->right!=NULL )
            {
                T->right->bPushed = false;//初始化当前节点的右节点（若存在）为false
                s.push(T->right);
            }

            if (T->left!=NULL )
            {
                T->left->bPushed = false;//初始化当前节点的左节点（若存在）为false
                s.push(T->left);
            }

        }
    }
    cout<<endl;
}

void preOrder(Tree T)
{
    if (T!=NULL)
    {
        cout<<T->element<<" ";
        preOrder(T->left);
        preOrder(T->right);
    }
}

void inOrder(Tree T)
{
    if (T!=NULL)
    {
        inOrder(T->left);
        cout<<T->element<<" ";
        inOrder(T->right);
    }
}

void postOrder(Tree T)
{
    if (T!=NULL)
    {
        postOrder(T->left);
        postOrder(T->right);
        cout<<T->element<<" ";
    }
}
int main()
{

    Tree T = NULL;
    Insert(10,T);
    Insert(20,T);
    Insert(8,T);
    Insert(15,T);
    Insert(1,T);
    Insert(9,T);
    Insert(28,T);
    preOrder(T);cout<<endl;
    inOrder(T);cout<<endl;
    postOrder(T);cout<<endl;
    PreOrderTraversal(T);
    InOrderTraversal(T);
    PostOrderTraversal(T);
    system("pause");
    return 0;
}