二叉树的非递归遍历

二叉树的遍历我想大家都知道了，主要有先序、中序、后序，递归的遍历我就不说了，今天小编给大家主要介绍下二叉树的非递归遍历。

节点结构体：

#include<stack>
enum tag { L, R };
template<typename T>//可以变成类
struct BintNode
{
    BintNode():left(nullptr),right(nullptr),value(0){}
    BintNode(T v)
    {
        left = nullptr;
        right = nullptr;
        value = v;
    }
    T value;
    BintNode<T> *left;
    BintNode<T> *right;    
};
template<typename E>
struct stkNode
{
    stkNode(BintNode<E>*N=nullptr):ptr(N), r(L){}
    BintNode<E>*ptr;
    tag r;
};

首先是先序遍历，借助栈实现的。

void nonrepreorder(BintNode<Y>*root)const//非递归先序
    {
        if (root)
        {
            stack<BintNode<Y>*> bitr;
            bitr.push(root);
            BintNode<Y>*p;
            while (!bitr.empty())
            {
                p = bitr.top();
                bitr.pop();
                cout << p->value;
                if (p->right != nullptr)
                   bitr.push(p->right);
                if(p->left!=nullptr)
                    bitr.push(p->left);
            }
        }
    }

下来时中序遍历

void nonreinorder(BintNode<Y>*root)const//非递归中序//左根右
    {
        if(root)
        {
            stack<BintNode<Y>*>bitr;
            BintNode<Y>*p = root;
            do
            {
                while(p!=nullptr)
                {
                    bitr.push(p);
                    p = p->left;
                }
                if(!bitr.empty())
                {
                    p=bitr.top();
                    bitr.pop();
                    cout << p->value;
                    p=p->right;
                }
            } while (!bitr.empty() || p != nullptr);
        }
    }

之后是后序遍历

void nonrepostorder(BintNode<Y>*root)const//非递归后序
    {
        if(root)
        {
            stack<stkNode<Y>>bitr;
            stkNode<Y>w;
            BintNode<Y>*p=root;
            do
            {
                while(p)
                {
                    w.ptr = p; 
                    w.r = L;
                    bitr.push(w);
                    p = p->left;
                }
                int continuel = 1;
                while(continuel&&!bitr.empty())
                {
                    w = bitr.top();
                    bitr.pop();
                    p = w.ptr;
                    if (w.r == L)
                    {
                        w.r=R;
                        bitr.push(w);
                        continuel = 0;
                        p = w.ptr->right;
                    }
                    else
                        cout << w.ptr->value;
                }
            }
            while (!bitr.empty());
        }
    }

后序遍历小编在压栈时将节点进行了包装从而实现从左子树到右子树的转换。

 

最后在送大家一个层次遍历吧！

#include<queue>
void levelorder(BintNode<Y>*root)const
    {
        if(root!=NULL)
        {
            queue<BintNode<Y>*> que;
            que.push(root);
            while(!que.empty())
            {
                root = que.front();
                que.pop();
                if (root->left)
                    que.push(root->left);
                if (root->right)
                    que.push(root->right);
                cout << root->value << " ";
            }
            cout << endl;
        }
    }

-------------------------------------------------------------

  无冥冥之志者,无昭昭之明;无惛惛之事者,无赫赫之功!

来源：https://www.cnblogs.com/ycw1024/p/11395443.html