二叉树非递归遍历和层序遍历（各种版本）

先说下递归遍历吧，特别简单，交换三者的顺序，就能得到三种递归方式。

以先序遍历为例：

void preOrder1(BinTree *root)     //递归前序遍历 
{
    if(root!=NULL)
    {
        cout<<root->data<<" ";
        preOrder1(root->lchild);
        preOrder1(root->rchild);
    }
}

一：先序遍历非递归方式-----其实也可以看做深度优先算法

1、用栈实现

要设置一个栈，来模拟向上回溯的方式。

（1）如果左节点不空，就一直进行“访问该结点，入栈，p指向左子树”

（2）当p指向的结点为空的时候，就开始出栈了，出栈的是p的父节点pp，那么将p = pp->right，使得p指向其兄弟结点，再返回（1）进行递归访问。

（3）每次出栈的结点的右结点肯定没有被访问过，因此让p指向其右节点就行了。

void preOrder2(BinTree *root)     //非递归前序遍历 
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}

2、用栈实现

改进一：在方法一中，我们让根结点入栈，是为了方便找到根结点的右节点。这里我们可以直接让右节点入栈。

改进二：为了省去上面的不规则代码，先while循环，再if判断。我们可以直接先让右结点入栈，再让左结点入栈，这样的话，下次循环开始，就直接出栈就行了。相当于没入栈的时候，让p = p->left。

代码如下：

void preOrder(Node *p) //非递归
{
    if(!p) return;
    stack<Node*> s;
    Node *t;
    s.push(p);

    while(!s.empty()){
        t=s.top();
        cout << t.data << " ";
        s.pop();

        if(t->right) s.push(t->right);
        if(t->left) s.push(t->left);
    }
}

3、不用栈，但需要额外添加父节点指针和访问标记

先判断左孩子的访问标记，再判断右孩子的访问标记。如果左右孩子都被访问过，就让root指向root->parent。

// 先序遍历伪代码：非递归版本，不用栈，增加指向父节点的指针
void preOrder3(TNode* root)
{
    while ( root != NULL ){ // 回溯到根节点时为NULL，退出
        if( !root->bVisited ){   // 判定是否已被访问
            Visit(root);
            root->bVisited = true;
        }
        if ( root->left != NULL && !root->left->bVisited ){      // 访问左子树
            root = root->left;
        }
        else if( root->right != NULL && !root->right->bVisited ){ // 访问右子树
            root = root->right;
        }
        else{   // 回溯
            root = root->parent;
        }
    }
}

这个方法不太好，不能直接找到要被访问的右结点，需要一层一层向上走。也需要了额外的空间来存储父节点指针和访问标记。但有点是没有用到栈。

二：中序遍历非递归方式

1、用栈实现

参照先序遍历的方案一，我们直接将访问的方式，放到出栈的时候，因为这个时候出栈的是父节点。利用这个代码最简洁。

void InOrderTraverse1(BiTree T)   // 中序遍历的非递归    
{    
    if(!T)    
        return ;    
    BiTree curr = T;    // 指向当前要检查的节点    
    stack<BiTree> s;  
    while(curr != NULL || !s.empty())  
    {  
        while(curr != NULL)  
        {  
            s.push(curr);  
            curr = curr->lchild;  
        }//while  
        if(!s.empty())  
        {  
            curr = s.top();  
            s.pop();  
            cout<<curr->data<<"  ";  
            curr = curr->rchild;  
        }  
    }  
}  

2、用栈实现

如果参照先序遍历的方案二的话，就不能实现了，因为那里的栈中只保存了左右子树，没有跟结点信息。导致了没有办法实现中序遍历。

因此三个节点都要入栈，而且入栈的先后顺序必须为：右节点，根节点，左节点。但是，当入栈以后，根节点与其左右子树的节点就分不清楚了。因此必须引入一个标志位，表示 是否已经将该节点的左右子树入栈了。每次入栈时，根节点标志位为true,左右子树标志位为false。

下面用c++来实现，就用到pair类型。

void inOrder(Node *p)
{
    if(!p)
        return;
    stack< pair<Node*,int> > s;
    Node *t;
    int unUsed;

    s.push(make_pair(p,1));
    while(!s.empty()){
        t=s.top().first;
        unUsed = s.top().second;
        s.pop();//退出栈顶结点

        if(unUsed){//如果其左右子树都没有放入栈中
            if(t->right)            //按照右子树，根结点，左子树的顺序放入
                s.push( make_pair(t->right,1) );
            s.push( make_pair(t,0) );   //只有放入根结点的时候，要设置标记为0
            if(t->left)
                s.push( make_pair(t->left,1));
        }
        else printf("%d\n",t->data);
    }
}

3、不用栈

这个方法比较绕，参考下就行

中序遍历的第三个非递归版本：采用指向父节点的指针回溯。这个与先序遍历是非常类似的，不同之处在于，先序遍历只要一遇到节点，那么没有被访问那么立即访问，访问完毕后尝试向左走，如果左孩子补课访问，则尝试右边走，如果左右皆不可访问，则回溯；中序遍历是先尝试向左走，一直到左边不通后访问当前节点，然后尝试向右走，右边不通，则回溯。（这里不通的意思是：节点不为空，且没有被访问过）

// 中序遍历伪代码：非递归版本，不用栈，增加指向父节点的指针
void InOrder3(TNode* root)
{
    while ( root != NULL ) // 回溯到根节点时为NULL，退出
    {
        while ( root->left != NULL && !root->left->bVisited )
        {                  // 沿左子树向下搜索当前子树尚未访问的最左节点           
            root = root->left;
        }
        if ( !root->bVisited )
        {                  // 访问尚未访问的最左节点
            Visit(root);
            root->bVisited=true;
        }
        if ( root->right != NULL && !root->right->bVisited )
        {                  // 遍历当前节点的右子树  
            root = root->right;
        }
        else
        {                 // 回溯至父节点
            root = root->parent;
        }
    }
}

三、后序遍历非递归方式

1、用栈

（1）

void PostOrder_Nonrecursive1(BiTree T)  // 后序遍历的非递归      
{      
    stack<BiTree> S;      
    BiTree curr = T ;           // 指向当前要检查的节点    
    BiTree previsited = NULL;    // 指向前一个被访问的节点    
    while(curr != NULL || !S.empty())  // 栈空时结束      
    {      
        while(curr != NULL)            // 一直向左走直到为空    
        {      
            S.push(curr);      
            curr = curr->lchild;      
        }      
        curr = S.top();    
        // 当前节点的右孩子如果为空或者已经被访问，则访问当前节点    
        if(curr->rchild == NULL || curr->rchild == previsited)      
        {      
            cout<<curr->data<<"  ";      
            previsited = curr;      
            S.pop();      
            curr = NULL;      
        }      
        else    
            curr = curr->rchild;      // 否则访问右孩子    
    }      
}  

（2）

void PostOrder_Nonrecursive(BiTree T)  // 后序遍历的非递归     双栈法    
{      
    stack<BiTree> s1 , s2;      
    BiTree curr ;           // 指向当前要检查的节点    
    s1.push(T);    
    while(!s1.empty())  // 栈空时结束      
    {    
        curr = s1.top();    
        s1.pop();    
        s2.push(curr);    
        if(curr->lchild)    
            s1.push(curr->lchild);    
        if(curr->rchild)    
            s1.push(curr->rchild);    
    }    
    while(!s2.empty())    
    {    
        printf("%c ", s2.top()->data);    
        s2.pop();    
    }    
}

2、用栈

这个参考了中序遍历的第二种方法，入栈的顺序是，根结点、右子树、左子树。

void postOrder(Node *p)
{
    if(!p) return;
    stack<pair<Node*,int> > s;
    Node *t;

    int unUsed;
    s.push(make_pair(p,1));
    while(!s.empty()){
        t=s.top().first;
        unUsed=s.top().second;
        s.pop();

        if(unUsed){
            s.push(make_pair(t,0);

            if(t->right)
                s.push(make_pair(t->right,1));
            if(t->left)
                s.push(make_pair(t->left,1));
        }
        else printf("%d\n",t->data);
    }
}

四、层序遍历

利用队列，很简单

void levelOrderTraverse(const BiTree& T)  
{  
    queue<BiTree> q;  
    BiTree p = NULL;  
      
    if(T)//若根结点非空，则入队列   
    {  
        q.push(T);  
    }  
    while(!q.empty())//队列非空   
    {  
        p = q.front();  
        q.pop();  
        cout<<p->data<<" ";  
        if(p->lchild)//左孩子不空，入队列   
        {  
            q.push(p->lchild);  
        }  
        if(p->rchild)//右孩子不空，入队列   
        {  
            q.push(p->rchild);  
        }  
    }   
}