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

转载 2007年09月14日 23:04:00

图的深度优先搜索法是树的先根遍历的推广,它的基本思想是:从图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://steven-hong.javaeye.com/blog/493665 图的深度优先搜索法是树的先根遍历的推广,它的基本思想是:从图G...

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

图的深度优先搜索法是树的先根遍历的推广,它的基本思想是:从图G的某个顶点v0出发,访问v0,然后选择一个与v0相邻且没被访问过的顶点vi访问,再从vi出发选择一个与vi相邻且未被访问的顶点vj进行访问...

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

图的深度优先搜索法是树的先根遍历的推广,它的基本思想是:从图G的某个顶点v0出发,访问v0,然后选择一个与v0相邻且没被访问过的顶点vi访问,再从vi出发选择一个与vi相邻且未被访问的顶点vj进行访问...

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

  • 2013年04月20日 16:56
  • 3KB
  • 下载

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

树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的信息的访问,即依次对树中每个结点访问一次且仅访问一次,我们把这种对所有节点的访问称为遍历(traversal)。那么树的两种重要的遍历模式是深...

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

[转】二叉树与图的深度优先和广度优先遍历.  (2011-07-20 02:49:35) 转载▼ 标签:  杂谈   图的深度优...

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

深度优先搜索算法(Depth First Search),是搜索算法的一种。是沿着树的深度遍历树的节点,尽可能深的搜索树的分支。 当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起...

二叉树搜索树遍历--前序、中序、后序、深度优先、广度优先遍历的简单实现

一、相关说明 本例中构造的二叉树只有添加,没有修改和按照索引来查找等其他功能,因为我只想练习一下二叉搜索树的遍历方式。 本文采用Java实现。 二、代码说明 1)add(E element)方法 p...

二叉树的深度优先dfs遍历(前序、中序和后序;递归与非递归)

二叉树本身就是用递归定义的,因此采用递归方法实现dfs的三种遍历不仅容易理解而且代码简洁。 若用非递归实现,则要采用栈去模拟:保存计算的上下文,使得计算在返回上一级时有路可循。注意每一个结点都要当...
  • mach7
  • mach7
  • 2014年02月26日 15:18
  • 4423
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:二叉树的深度优先和广度优先遍历
举报原因:
原因补充:

(最多只允许输入30个字)