二叉树的深度优先和广度优先遍历

二叉树的深度优先和广度优先遍历


http://steven-hong.javaeye.com/blog/493665


图的深度优先搜索法是树的先根遍历的推广，它的基本思想是：从图G的某个顶点v0出发，访问v0，然后选择一个与v0相邻且没被访问过的顶点vi访问，再 从vi出发选择一个与vi相邻且未被访问的顶点vj进行访问，依次继续。如果当前被访问过的顶点的所有邻接顶点都已被访问，则退回到已被访问的顶点序列中 最后一个拥有未被访问的相邻顶点的顶点w，从w出发按同样的方法向前遍历，直到图中所有顶点都被访问。


图的广度优先搜索是树的按层次遍历的推广，它的基本思想是：首先访问初始点vi，并将其标记为已访问过，接着访问vi的所有未被访问过的邻接点 vi1,vi2, …, vi t，并均标记已访问过，然后再按照vi1,vi2, …, vi t的次序，访问每一个顶点的所有未被访问过的邻接点，并均标记为已访问过，依次类推，直到图中所有和初始点vi有路径相通的顶点都被访问过为止。


二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。


为了方便程序验证，首先构造一个如图所示的二叉树。


 


源码：


/*************************** bintree.h文件 *****************************/


#ifndef _BINTREE_H


#define _BINTREE_H


 


template <class T>


class CBintree


{


public:


       CBintree();


       bool Depth_RF();//先根深度遍历


       bool Depth_RM();//中根深度遍历


       bool WidthFS(); //层次遍历


protected:


private:   


       struct TreeNode


       {


              T va;


              TreeNode *plchild;


              TreeNode *prchild;


       };


       TreeNode *m_pBintree;


};


#endif


 


template <class T>


CBintree<T>::CBintree()


{


       m_pBintree = new TreeNode;      


       TreeNode *pNode2 = new TreeNode;


       TreeNode *pNode3 = new TreeNode;


    TreeNode *pNode4 = new TreeNode;


       TreeNode *pNode5 = new TreeNode;


       TreeNode *pNode6 = new TreeNode;


       TreeNode *pNode7 = new TreeNode;


      


       m_pBintree->va = (T)1;


       m_pBintree->plchild = pNode2;


       m_pBintree->prchild = pNode3;


      


    pNode2->va = (T)2;


       pNode2->plchild = pNode4;


    pNode2->prchild = pNode5;


      


       pNode3->va = (T)3;


       pNode3->plchild = NULL;


       pNode3->prchild = pNode6;


      


       pNode4->va = (T)4;


       pNode4->plchild = NULL;


       pNode4->prchild = NULL;


      


       pNode5->va = (T)5;


       pNode5->plchild = pNode7;


       pNode5->prchild = NULL;


      


       pNode6->va = (T)6;


       pNode6->plchild = NULL;


       pNode6->prchild = NULL;


      


       pNode7->va = (T)7;


       pNode7->plchild = NULL;


       pNode7->prchild = NULL;


}


 


template <class T>


bool CBintree<T>::Depth_RF() //先根深度遍历


{


       cout << "先根遍历序列:\n";


       stack <TreeNode> s;    


       s.push(*m_pBintree);


       while (!s.empty())


       {


              TreeNode node_s = s.top();


              cout << node_s.va << "\n";


              s.pop();


              if (node_s.prchild != NULL)


              {


                     s.push(*node_s.prchild);


              }


              if (node_s.plchild != NULL)


              {


                     s.push(*node_s.plchild);


              }


             


       }


 


       return true;


}


 


template <class T>


bool CBintree<T>::Depth_RM() //中根深度遍历


{


       cout << "中根遍历序列:\n";


       stack <TreeNode> s;    


    TreeNode *pNode = m_pBintree;


       while (pNode != NULL || !s.empty())


       {


              while (pNode != NULL)


              {


                     s.push(*pNode);


                     pNode = pNode->plchild;


              }


             


              if (!s.empty())


              {


                     TreeNode node_s = s.top();


                     cout << node_s.va << "\n";


                     s.pop();


                     pNode = node_s.prchild;


              }


       }    


       return true;


}


 


template <class T>


bool CBintree<T>::WidthFS() //层次遍历


{


       cout << "层次遍历序列:\n";


       queue <TreeNode> q;


       q.push(*m_pBintree);


       while (!q.empty())


       {


              TreeNode *pNode = &q.front();


              cout << pNode->va << "\n";


              if (pNode->plchild != NULL)


              {


                     q.push(*pNode->plchild);


              }


              if (pNode->prchild != NULL)


              {


                     q.push(*pNode->prchild);


              }


              q.pop();  


       }


 


       return true;


}


 


/************************ main.cpp 文件 ****************************/


#include <iostream>


#include <stack>


#include <queue>


using namespace std;


 


#include "bintree.h"


 


int main()


{


       CBintree <int> bt;


       bt.Depth_RF();


       bt.Depth_RM();


       bt.WidthFS();


       return 0;


}


/***************** 教科书标准算法及优化算法（转）*******************/
1.先序遍历非递归算法
void PreOrderUnrec(Bitree *t)
{
    Stack s;
    StackInit(s);
    Bitree *p=t;
   
    while (p!=NULL || !StackEmpty(s))
    {
        while (p!=NULL)             //遍历左子树
        {
            visite(p->data);
            push(s,p);
            p=p->lchild;  
        }
        
        if (!StackEmpty(s))         //通过下一次循环中的内嵌while实现右子树遍历
        {
            p=pop(s);
            p=p->rchild;        
        }//endif
               
    }//endwhile 
}




2.中序遍历非递归算法
void InOrderUnrec(Bitree *t)
{
    Stack s;
    StackInit(s);
    Bitree *p=t;


    while (p!=NULL || !StackEmpty(s))
    {
        while (p!=NULL)             //遍历左子树
        {
            push(s,p);
            p=p->lchild;
        }
        
        if (!StackEmpty(s))
        {
            p=pop(s);
            visite(p->data);        //访问根结点
            p=p->rchild;            //通过下一次循环实现右子树遍历
        }//endif   
   
    }//endwhile
}


3.后序遍历非递归算法
typedef enum{L,R} tagtype;
typedef struct
{
    Bitree ptr;
    tagtype tag;
}stacknode;


typedef struct
{
    stacknode Elem[maxsize];
    int top;
}SqStack;


void PostOrderUnrec(Bitree t)
{
    SqStack s;
    stacknode x;
    StackInit(s);
    p=t;
   
    do
    {
        while (p!=null)        //遍历左子树
        {
            x.ptr = p;
            x.tag = L;         //标记为左子树
            push(s,x);
            p=p->lchild;
        }
   
        while (!StackEmpty(s) && s.Elem[s.top].tag==R)  
        {
            x = pop(s);
            p = x.ptr;
            visite(p->data);   //tag为R，表示右子树访问完毕，故访问根结点      
        }
        
        if (!StackEmpty(s))
        {
            s.Elem[s.top].tag =R;     //遍历右子树
            p=s.Elem[s.top].ptr->rchild;        
        }   
    }while (!StackEmpty(s));
}//PostOrderUnrec


 


4.前序最简洁非递归算法


void PreOrderUnrec(Bitree *t)


{


       Bitree *p;


       Stack s;


       s.push(t);


      


       while (!s.IsEmpty())


       {


              s.pop(p);


              visit(p->data);


              if (p->rchild != NULL) s.push(p->rchild);


              if (p->lchild != NULL) s.push(p->lchild);


       }


}


 


5.后序算法之二


void BT_PostOrderNoRec(pTreeT root)


{


       stack<treeT *> s;


       pTreeT pre=NULL;


      


       while ((NULL != root) || !s.empty())


       {


              if (NULL != root)


              {


                     s.push(root);


                     root = root->left;


              }


              else


              {


                     root = s.top();


                     if (root->right!=NULL && pre!=root->right){


                            root=root->right;


                     }


                     else{


                            root=pre=s.top();


                            visit(root);


                            s.pop();


                            root=NULL;


                     }


              }


       }

}

转自：http://www.cnblogs.com/sunnytracy/archive/2009/10/27/1590876.html