二叉树的非递归遍历

二叉树的前序非递归遍历:

 前序遍历的顺序：根结点——左孩子——右孩子“。

根据前序遍历访问结点的顺序可知：优先访问根结点，然后再分别访问左孩子和右孩子。

对于任意结点来说，都可将其视为根结点，因此可直接访问，访问完之后，若其左孩子不为空，则按照相同规则访问左子树；当访问了左子树之后，再访问它的右子树。

其处理过程如下：

对于任一结点 P：
1）若P结点不为空，则将其入栈并且访问该结点，然后将其左孩子置为下个要访问的结点。执行步骤1);
2）若P结点为空，则取出栈顶元素，并将其右孩子置为下个要访问的结点，然后循环执行1）。
3）直到P为空，并且栈也为空是，退出循环，即遍历结束。

代码如下：

void PreTraversal_Non_Recursive(pBTree T) // 前序非递归遍历
{
    if( T == NULL)
        return;    
    
    stack<pBTree> st;

    pBTree p = T;
    while( p!= NULL || !st.empty())
    {
        while( p != NULL) //p不为空时
        {
            cout << p->data_ <<" "; //访问p结点
            st.push(p); //压入栈中
            p = p->left_; //访问其左子树
        }
        
        if( !st.empty() )
        {
            p = st.top();
            st.pop(); //弹出
            p = p->right_;
        }
    }
}

二叉树的中序非递归遍历:

中序遍历的顺序：”左孩子——根结点——右孩子“；

中序遍历过程和前序类似，其处理过程如下：

对于任一结点 P：
1）若P结点不为空，则将其入栈，然后将其左孩子置为下个要访问的结点。执行步骤1);
2）若P结点为空，则取出栈顶元素并且访问该结点，并将其右孩子置为下个要访问的结点，然后循环执行1）。
3）直到P为空，并且栈也为空是，退出循环，即遍历结束。

代码如下：

void InOrder_Traversal_Non_Recursive(pBTree T) //终须遍历(非递归)
{
    if( T == NULL)
        return;    

    stack<pBTree> st;
    pBTree p = T;

    while( p != NULL || !st.empty())
    {
        while( p != NULL)
        {
            st.push(p);
            p = p->left_;
        }

        if( !st.empty())
        {
            p = st.top();
            cout << p->data_ << " ";
            st.pop();
            p = p->right_;
        }
    }
}

二叉树的后序非递归遍历:

前序遍历的顺序：左孩子——右孩子——根结点“。

后续遍历较为麻烦，因为后续非递归遍历二叉树的顺序是先访问左子树，再访问右子树，最后访问其根结点，当用栈来存储结点是，必须分清返回根结点时，是从左子树返回的，还是从右子树返回的。

思路如下：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任意结点，先将其入栈。

1）如果P不存在左孩子和右孩子，则可以直接访问它；

2）P存在左孩子或者右孩子，但是左孩子或者右孩子都已经被访问过了，则同样可以直接访问该结点。

3）除此之外，即存在左孩子或者右孩子并且还都没有访问，这时，我们先将其右孩子入栈，然后将左孩子入栈，这样我们就保证了每次取出站定元素的时候，左孩子在右孩子前面　　被访问。并且也能保证左孩子或者右孩子能在根结点之前访问。

代码如下：

void PostOrder_Traversal_Non_Recursive(pBTree T) //非递归后序遍历
{
    if( T == NULL)
        return;

    pBTree cur; //当前访问的结点
    pBTree pre = NULL; //前一次访问的结点
    stack<pBTree> st;
    st.push(T);

    while( !st.empty())
    {
        cur = st.top();

        //当前结点没有孩子结点 或者 当前结点的左孩子或者右孩子已经被访问过 
        if( (cur->left_ == NULL && cur->right_==NULL) || 
            ( pre!= NULL &&(pre ==cur->left_ || pre == cur->right_) ) )
        {
            cout << cur->data_ <<" ";
            st.pop();
            pre = cur;
        }
        else
        {
            if( cur->right_ != NULL)
                st.push(cur->right_);
            if( cur->left_  != NULL)
                st.push(cur->left_);
        }
    }
}

全部实现代码如下：

#include <iostream>
#include <string>
#include <stack>
#include <assert.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int N =10;

typedef struct node //二叉树的数据结构
{
    int data_;
    struct node* left_;
    struct node* right_;
}BTree, *pBTree;

void  Create_Btree_with_arr(pBTree &T, int *arr, int begin, int end)//len俄日数组的长度，也是树的结点数
{
    if(begin > end)
        return;

    int mid = (begin + end)/2;
    if( T == NULL)
    {
        T =new BTree; //申请空间
        arr[mid] = rand()%100;
        cout<< arr[mid] <<" ";
        T->data_ = arr[mid]; //数值随机化
        T->left_ = NULL;
        T->right_ = NULL;
    }
    Create_Btree_with_arr(T->left_, arr, begin, mid-1);//左边(不包括T)
    Create_Btree_with_arr(T->right_, arr, mid+1, end); //右边(不包括T)
}

void PreTraversal_Non_Recursive(pBTree T) // 前序非递归遍历
{
    if( T == NULL)
        return;    
    
    stack<pBTree> st;

    pBTree p = T;
    while( p!= NULL || !st.empty())
    {
        while( p != NULL) //p不为空时
        {
            cout << p->data_ <<" "; //访问p结点
            st.push(p); //压入栈中
            p = p->left_; //访问其左子树
        }
        
        if( !st.empty() )
        {
            p = st.top();
            st.pop(); //弹出
            p = p->right_;
        }
    }
}

void InOrder_Traversal_Non_Recursive(pBTree T) //终须遍历(非递归)
{
    if( T == NULL)
        return;    

    stack<pBTree> st;
    pBTree p = T;

    while( p != NULL || !st.empty())
    {
        while( p != NULL)
        {
            st.push(p);
            p = p->left_;
        }

        if( !st.empty())
        {
            p = st.top();
            cout << p->data_ << " ";
            st.pop();
            p = p->right_;
        }
    }
}

void PostOrder_Traversal_Non_Recursive(pBTree T) //非递归后序遍历
{
    if( T == NULL)
        return;

    pBTree cur; //当前访问的结点
    pBTree pre = NULL; //前一次访问的结点
    stack<pBTree> st;
    st.push(T);

    while( !st.empty())
    {
        cur = st.top();

        //当前结点没有孩子结点 或者 当前结点的左孩子或者右孩子已经被访问过 
        if( (cur->left_ == NULL && cur->right_==NULL) || 
            ( pre!= NULL &&(pre ==cur->left_ || pre == cur->right_) ) )
        {
            cout << cur->data_ <<" ";
            st.pop();
            pre = cur;
        }
        else
        {
            if( cur->right_ != NULL)
                st.push(cur->right_);
            if( cur->left_  != NULL)
                st.push(cur->left_);
        }
    }
}

void DestructBTree( pBTree &T) //二叉树的销毁
{
    if( T == NULL)
        return;

    DestructBTree( T->left_);
    DestructBTree( T->right_);
    delete T; //free之后的指针成为了野指针，内容并不为空
    T = NULL;//置空
}

int main(int argc, char const *argv[])
{
    srand(time(NULL));
    int arr[N]= {0};

    pBTree T =NULL;
    Create_Btree_with_arr(T, arr, 0,N-1);
    cout << endl;

    PreTraversal_Non_Recursive(T);
    cout << endl;

    InOrder_Traversal_Non_Recursive(T);
    cout << endl;

    PostOrder_Traversal_Non_Recursive(T);
    cout << endl;

    DestructBTree(T);
    cout <<"Free Over" << endl;
    assert( T == NULL); //验证 T 是否真的被释放
    return 0;
}

完毕。