深度优先和广度优先搜索

一、二叉树深度优先(DFS)和广度优先(BFS)搜索算法

树的相关概念参见 红黑树详解

(1)深度优先搜索算法(Depth First Search),是搜索算法的一种。是沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止。


如下图所示的二叉树:



A 是第一个访问的,然后顺序是 B、D,然后是 E。接着再是 C、F、G。那么,怎么样才能来保证这个访问的顺序呢?分析一下,在遍历了根结点后,就开始遍历左子树,最后才是右子树。因此可以借助堆栈的数据结构,由于堆栈是后进先出的顺序,由此可以先将右子树压栈,然后再对左子树压栈,这样一来,左子树结点就存在了栈顶上,因此某结点的左子树能在它的右子树遍历之前被遍历。

深度优先遍历代码片段:

//深度优先遍历:非递归,使用栈模拟
void depthFirstSearch(Tree root){
    stack<Node *> nodeStack;  //使用C++的STL标准模板库
    nodeStack.push(root);
    Node *node;
    while(!nodeStack.empty()){
        node = nodeStack.top();
        printf(format, node->data);  //遍历根结点
        nodeStack.pop();
        if(node->rchild){
            nodeStack.push(node->rchild);  //先将右子树压栈
        }
        if(node->lchild){
            nodeStack.push(node->lchild);  //再将左子树压栈
        }
    }
}

//深度优先遍历:递归,中序遍历
void MidOrder(TreeNode node)         
{            
    if (node != null)            
    {                
        MidOrder(node->lchild);                
        printf(format, node->data);  //遍历根结点             
        MidOrder(node->lchild);            
    }            
    else            
    {                
        //done            
    }        
}

(2)广度优先搜索算法(Breadth First Search),又叫宽度优先搜索,或横向优先搜索。是从根节点开始,沿着树的宽度遍历树的节点。如果所有节点均被访问,则算法中止。

如下图所示的二叉树:

A 是第一个访问的,然后顺序是 B、C,然后再是 D、E、F、G。那么,怎样才能来保证这个访问的顺序呢?借助队列数据结构,由于队列是先进先出的顺序,因此可以先将左子树入队,然后再将右子树入队。这样一来,左子树结点就存在队头,可以先被访问到。

广度优先遍历代码片段:

//广度优先遍历:使用队列模拟
void breadthFirstSearch(Tree root){
    queue<Node *> nodeQueue;  //使用C++的STL标准模板库
    nodeQueue.push(root);
    Node *node;
    while(!nodeQueue.empty()){
        node = nodeQueue.front();
        nodeQueue.pop();
        printf(format, node->data);
        if(node->lchild){
            nodeQueue.push(node->lchild);  //先将左子树入队
        }
        if(node->rchild){
            nodeQueue.push(node->rchild);  //再将右子树入队
        }
    }
}

 

二、图的深度优先(DFS)和广度优先(BFS)搜索算法

在介绍图的搜索之前,有必要先了解计算机中图的存储方式。图的存储表示方法很多,这里介绍两种最常用的方法。至于具体选择哪一种表示法,主要取决于具体的应用和欲施加的操作。为了适合用C语言描述,以下假定顶点序号从0开始,即图G的顶点集的一般形式是V(G)={v0,vi,…,Vn-1}。
(1)图的邻接矩阵表示法
1.图的邻接矩阵表示法
     

在图的邻接矩阵表示法中:  

  ① 用邻接矩阵表示顶点间的相邻关系  

  ② 用一个顺序表来存储顶点信息

2.图的邻接矩阵(Adacency Matrix)      

设G=(V,E)是具有n个顶点的图,则G的邻接矩阵是具有如下性质的n阶方阵:   

   
【例】下图中无向图G5和有向图G6的邻接矩阵分别为Al和A2

   

3.网络的邻接矩阵      

若G是网络,则邻接矩阵可定义为:    

        
其中:      

  wij表示边上的权值;      

  ∞表示一个计算机允许的、大于所有边上权值的数。

【例】下面带权图的两种邻接矩阵分别为A3和A4


       
4.图的邻接矩阵存储结构形式说明   

#define MaxVertexNum l00 //最大顶点数,应由用户定义
  typedef char VertexType; //顶点类型应由用户定义
  typedef int EdgeType; //边上的权值类型应由用户定义
  typedef struct{
      VextexType vexs[MaxVertexNum] //顶点表
      EdeType edges[MaxVertexNum][MaxVertexNum];
                    //邻接矩阵,可看作边表
      int n,e; //图中当前的顶点数和边数
   }MGragh;

注意:     

  ① 在简单应用中,可直接用二维数组作为图的邻接矩阵(顶点表及顶点数等均可省略)。      

  ② 当邻接矩阵中的元素仅表示相应的边是否存在时,EdgeTyPe可定义为值为0和1的枚举类型。      

  ③ 无向图的邻接矩阵是对称矩阵,对规模特大的邻接矩阵可压缩存储。      

  ④ 邻接矩阵表示法的空间复杂度S(n)=0(n2)。

5.建立无向网络的算法。 

void CreateMGraph(MGraph *G)
    {//建立无向网的邻接矩阵表示
      int i,j,k,w;
      scanf("%d%d",&G->n,&G->e); //输入顶点数和边数
      for(i=0;i<G->n;i++) //读人顶点信息,建立顶点表
        G->vexs[i]=getchar();
      for(i=0;i<G->n;i++)
        for(j=0;j<G->n;j++) 
          G->edges[i][j]=0//邻接矩阵初始化
      for(k=0;k<G->e;k++){//读入e条边,建立邻接矩阵
        scanf("%d%d%d",&i,&j,&w);//输入边(vi,vj)上的权w
        G->edges[i][j]=w;
        G->edges[j][i]=w;
       }
    }//CreateMGraph

该算法的执行时间是0(n+n2+e)。由于e<n2,算法的时间复杂度是0(n2)。

(2)图的邻接表表示法 
  图的邻接表表示法类似于树的孩子链表表示法。对于图G中的每个顶点vi,该方法把所有邻接于vi的顶点vj链成一个带头结点的单链表,这个单链表就称为顶点vi的邻接表(Adjacency
List)。
1. 邻接表的结点结构
(1)表结点结构

邻接表中每个表结点均有两个域:
  ① 邻接点域adjvex:存放与vi相邻接的顶点vj的序号j。
  ② 链域next:将邻接表的所有表结点链在一起。
注意:若要表示边上的信息(如权值),则在表结点中还应增加一个数据域。

(2)头结点结构

顶点vi邻接表的头结点包含两个域:
  ① 顶点域vertex:存放顶点vi的信息
  ② 指针域firstedge:vi的邻接表的头指针。

注意:
   ① 为了便于随机访问任一顶点的邻接表,将所有头结点顺序存储在一个向量中就构成了图的邻接表表示。
     ② 有时希望增加对图的顶点数及边数等属性的描述,可将邻接表和这些属性放在一起来描述图的存储结构。
2.无向图的邻接表

  对于无向图,vi的邻接表中每个表结点都对应于与vi相关联的一条边。因此,将邻接表的表头向量称为顶点表。将无向图的邻接表称为边表。
【例】对于无向图G5,其邻接表表示如下面所示,其中顶点v0的边表上三个表结点中的顶点序号分别为1、2和3,它们分别表示关联于v0的三条边(v0,v1),(v0,v2)和(v0,v3)。

注意:n个顶点e条边的无向图的邻接表表示中有n个顶点表结点和2e个边表结点。
3.有向图的邻接表
  对于有向图,vi的邻接表中每个表结点都对应于以vi为始点射出的一条边。因此,将有向图的邻接表称为出边表。
【例】有向图G6的邻接表表示如下面(a)图所示,其中顶点v1的邻接表上两个表结点中的顶点序号分别为0和4,它们分别表示从v1射出的两条边(简称为v1的出边):<v1,v0>和<v1,v4>。

 注意:n个顶点e条边的有向图,它的邻接表表示中有n个顶点表结点和e个边表结点。
4.有向图的逆邻接表
在有向图中,为图中每个顶点vi建立一个入边表的方法称逆邻接表表示法。
入边表中的每个表结点均对应一条以vi为终点(即射入vi)的边。
【例】G6的逆邻表如上面(b)图所示,其中v0的人边表上两个表结点1和3分别表示射人v0的两条边(简称为v0的入边):<v1,v0>和<v3,v0>。
注意:n个顶点e条边的有向图,它的接表表示中有n个顶点表结点和e个边表结点。

5.邻接表的形式说明及其建表算法
(1)邻接表的形式说明

typedef struct node{//边表结点
       int adjvex; //邻接点域
       struct node *next; //链域
     //若要表示边上的权,则应增加一个数据域
   }EdgeNode;
     typedef struct vnode{ //顶点表结点
       VertexType vertex; //顶点域
       EdgeNode *firstedge;//边表头指针
    }VertexNode;
     typedef VertexNode AdjList[MaxVertexNum];//AdjList是邻接表类型
      typedef struct{
       AdjList adjlist;//邻接表
       int n,e; // 图中当前顶点数和边数 
   }ALGraph; //对于简单的应用,无须定义此类型,可直接使用AdjList类型。

(2)建立无向图的邻接表算法

void CreateALGraPh(ALGrahp *G)
    {//建立无向图的邻接表表示
      int i,j,k;
      EdgeNode *s;
      scanf("%d%d",&G->n,&G->e); //读人顶点数和边数
      for(i=0;i<G->n;i++){//建立顶点表
        G->adjlist[i].vertex=getchar(); //读入顶点信息
        G->adjlist[i].firstedge=NULL;//边表置为空表
       }
      for(k=0;k<G->e;k++){//建立边表
         scanf("%d%d",&i,&j);// 读入边(vi,vj)的顶点对序号
         s=(EdgeNode *)malloc(sizeof(EdgeNode)); //生成边表结点
         s->adjvex=j; //邻接点序号为j
         s->next=G->adjlist[i].firstedge;
         G->adjlist[i].firstedge=s; //将新结点*s插入顶点vi的边表头部
         s=(EdgeNode *)malloc(sizeof(EdgeNode));
         s->adjvex=i; //邻接点序号为i
         s->next=G->adjlist[j].firstedge;
         G->adjlistk[j].firstedge=s; //将新结点*s插入顶点vj的边表头部
        }//end for 
   }CreateALGraph

该算法的时间复杂度是O(n+e)。
注意:

  ①建立有向图的邻接表更简单,每当读人一个顶点对序号<i,j>时,仅需生成一个邻接序号为j的边表结点,将其插入到vj的出边表头部即可。
  ② 建立网络的邻接表时,需在边表的每个结点中增加一个存储边上权的数据域。

 

(3)图的遍历

1、图的遍历
  和树的遍历类似,图的遍历也是从某个顶点出发,沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。它是许多图的算法的基础。深度优先遍历和广度优先遍历是最为重要的两种遍历图的方法。它们对无向图和有向图均适用。

注意:
  以下假定遍历过程中访问顶点的操作是简单地输出顶点。

2、布尔向量visited[0..n-1]的设置
  图中任一顶点都可能和其它顶点相邻接。在访问了某顶点之后,又可能顺着某条回路又回到了该顶点。为了避免重复访问同一个顶点,必须记住每个已访问的顶点。为此,可设一布尔向量visited[0..n-1],其初值为假,一旦访问了顶点Vi之后,便将visited[i]置为真。

 

深度优先遍历(Depth-First Traversal)

1.图的深度优先遍历的递归定义

假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点),则深度优先遍历可定义如下:首先访问出发点v,并将其标记为已访问过;然后依次从v出发搜索v的每个邻接点w。若w未曾访问过,则以w为新的出发点继续进行深度优先遍历,直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有未访问的顶点,则另选一个尚未访问的顶点作为新的源点重复上述过程,直至图中所有顶点均已被访问为止。
     图的深度优先遍历类似于树的前序遍历。采用的搜索方法的特点是尽可能先对纵深方向进行搜索。这种搜索方法称为深度优先搜索(Depth-First Search)。相应地,用此方法遍历图就很自然地称之为图的深度优先遍历。

2、深度优先搜索的过程
     设x是当前被访问顶点,在对x做过访问标记后,选择一条从x出发的未检测过的边(x,y)。若发现顶点y已访问过,则重新选择另一条从x出发的未检测过的边,否则沿边(x,y)到达未曾访问过的y,对y访问并将其标记为已访问过;然后从y开始搜索,直到搜索完从y出发的所有路径,即访问完所有从y出发可达的顶点之后,才回溯到顶点x,并且再选择一条从x出发的未检测过的边。上述过程直至从x出发的所有边都已检测过为止。此时,若x不是源点,则回溯到在x之前被访问过的顶点;否则图中所有和源点有路径相通的顶点(即从源点可达的所有顶点)都已被访问过,若图G是连通图,则遍历过程结束,否则继续选择一个尚未被访问的顶点作为新源点,进行新的搜索过程。

3、深度优先遍历的递归算法

//(1)深度优先遍历算法
  typedef enum{FALSE,TRUE}Boolean;//FALSE为0,TRUE为1
  Boolean visited[MaxVertexNum]; //访问标志向量是全局量
  void DFSTraverse(ALGraph *G)
  { //深度优先遍历以邻接表表示的图G,而以邻接矩阵表示G时,算法完全与此相同
    int i;
    for(i=0;i<G->n;i++)
      visited[i]=FALSE; //标志向量初始化
    for(i=0;i<G->n;i++)
      if(!visited[i]) //vi未访问过
        DFS(G,i); //以vi为源点开始DFS搜索
   }//DFSTraverse

//(2)邻接表表示的深度优先搜索算法
  void DFS(ALGraph *G,int i){ 
    //以vi为出发点对邻接表表示的图G进行深度优先搜索
    EdgeNode *p;
    printf("visit vertex:%c",G->adjlist[i].vertex);//访问顶点vi
    visited[i]=TRUE; //标记vi已访问
    p=G->adjlist[i].firstedge; //取vi边表的头指针
    while(p){//依次搜索vi的邻接点vj,这里j=p->adjvex
      if (!visited[p->adjvex])//若vi尚未被访问
        DFS(G,p->adjvex);//则以Vj为出发点向纵深搜索
      p=p->next; //找vi的下一邻接点
     }
   }//DFS

//(3)邻接矩阵表示的深度优先搜索算法
  void DFSM(MGraph *G,int i)
  { //以vi为出发点对邻接矩阵表示的图G进行DFS搜索,设邻接矩阵是0,l矩阵
    int j;
    printf("visit vertex:%c",G->vexs[i]);//访问顶点vi
    visited[i]=TRUE;
    for(j=0;j<G->n;j++) //依次搜索vi的邻接点
      if(G->edges[i][j]==1&&!visited[j])
        DFSM(G,j)//(vi,vj)∈E,且vj未访问过,故vj为新出发点
   }//DFSM

4、算法分析 
  对于具有n个顶点和e条边的无向图或有向图,遍历算法DFSTraverse对图中每顶点至多调用一次DFS或DFSM。从DFSTraverse中调用DFS(或DFSM)及DFS(或DFSM)内部递归调用自己的总次数为n。
  当访问某顶点vi时,DFS(或DFSM)的时间主要耗费在从该顶点出发搜索它的所有邻接点上。用邻接矩阵表示图时,其搜索时间为O(n);用邻接表表示图时,需搜索第i个边表上的所有结点。因此,对所有n个顶点访问,在邻接矩阵上共需检查n2个矩阵元素,在邻接表上需将边表中所有O(e)个结点检查一遍。
所以,DFSTraverse的时间复杂度为O(n2) (调用DFSM)或0(n+e)(调用DFS)。

5、深度优先遍历的非递归算法

// 图的深度优先遍历:非递归,邻接矩阵存储
void DFSTraverse_NonRecursion(ALGraph *G)  
{  
    int i, j, k;  
    stack st;  
   EdgeNode *p;
for(i=0; i<G->n; i++) visited[i]=FALSE; for(i=0; i<G->n; i++) // 遍历所有点,处理包括非连通图情况 if(!visited[i]) { visited[i]=TRUE; printf("visit vertex:%c",G->vexs[i]);//访问顶点vi push_stack(st, i); k = i;
       
while (!empty_stack(st)) {
          p = st.top();
          k = p->adjvex;
          st.pop();
for(j=0;j<G->n;j++) { if(G->edges[k][j]==1 && !visited[j]) { visited[j]=TRUE; printf("visit vertex:%c",G->vexs[j]);//访问顶点vi st.push(j); k = j; } } } } }

 

广度优先遍历(Breadth-FirstTraversal)

1、广度优先遍历的递归定义      

设图G的初态是所有顶点均未访问过。在G中任选一顶点v为源点,则广度优先遍历可以定义为:首先访问出发点v,接着依次访问v的所有邻接点w1,w2,…,wt,然后再依次访问与wl,w2,…,wt邻接的所有未曾访问过的顶点。依此类推,直至图中所有和源点v有路径相通的顶点都已访问到为止。此时从v开始的搜索过程结束。      

若G是连通图,则遍历完成;否则,在图C中另选一个尚未访问的顶点作为新源点继续上述的搜索过程,直至G中所有顶点均已被访问为止。      

广度优先遍历类似于树的按层次遍历。采用的搜索方法的特点是尽可能先对横向进行搜索,故称其为广度优先搜索(Breadth-FirstSearch)。相应的遍历也就自然地称为广度优先遍历。

2、广度优先搜索过程     

在广度优先搜索过程中,设x和y是两个相继要被访问的未访问过的顶点。它们的邻接点分别记为x1,x2,…,xs和y1,y2,…,yt。      

为确保先访问的顶点其邻接点亦先被访问,在搜索过程中使用FIFO队列来保存已访问过的顶点。当访问x和y时,这两个顶点相继入队。此后,当x和y相继出队时,我们分别从x和y出发搜索其邻接点x1,x2,…,xs和y1,y2,…,yt,对其中未访者进行访问并将其人队。这种方法是将每个已访问的顶点人队,故保证了每个顶点至多只有一次人队。

3、广度优先搜索算法

//(1)邻接表表示图的广度优先搜索算法
  void BFS(ALGraph*G,int k)
  {// 以vk为源点对用邻接表表示的图G进行广度优先搜索
    int i;
    CirQueue Q; //须将队列定义中DataType改为int
    EdgeNode *p;
    InitQueue(&Q);//队列初始化
     //访问源点vk
     printf("visit vertex:%e",G->adjlist[k].vertex);
    visited[k]=TRUE; 
    EnQueue(&Q,k);//vk已访问,将其人队。(实际上是将其序号人队)
    while(!QueueEmpty(&Q)){//队非空则执行
        i=DeQueue(&Q); //相当于vi出队
        p=G->adjlist[i].firstedge; //取vi的边表头指针
        while(p){//依次搜索vi的邻接点vj(令p->adjvex=j)
            if(!visited[p->adivex]){ //若vj未访问过
              printf("visitvertex:%c",C->adjlistlp->adjvex].vertex); //访问vj
              visited[p->adjvex]=TRUE; 
              EnQueue(&Q,p->adjvex);//访问过的vj人队
             }//endif
            p=p->next;//找vi的下一邻接点
         }//endwhile
      }//endwhile
   }//end of BFS 


//(2)邻接矩阵表示的图的广度优先搜索算法
  void BFSM(MGraph *G,int k)
  {// 以vk为源点对用邻接矩阵表示的图G进行广度优先搜索
   int i,j;
   CirQueue Q;
  InitQueue(&Q);
   printf("visit vertex:%c",G->vexs[k]); //访问源点vk
   visited[k]=TRUE;
   EnQueue(&Q,k);
   while(!QueueEmpty(&Q)){
      i=DeQueue(&Q); //vi出队
      for(j=0;j<G->n;j++)//依次搜索vi的邻接点vj
          if(G->edges[i][j]==1&&!visited[j]){//vi未访问
              printf("visit vertex:%c",G->vexs[j]);//访问vi
              visited[j]=TRUE;
              EnQueue(&Q,j);//访问过的vi人队
                 }
     }//endwhile
  }//BFSM

4、算法分析
 对于具有n个顶点和e条边的无向图或有向图,每个顶点均入队一次。广度优先遍历(BFSTraverse)图的时间复杂度和DFSTraverse算法相同。
 当图是连通图时,BFSTraverse算法只需调用一次BFS或BFSM即可完成遍历操作,此时BFS和BFSM的时间复杂度分别为O(n+e)和0(n2)。

 

 【参考】http://sjjp.tjuci.edu.cn/sjjg/DataStructure/DS/web/tu/tu7.1.1.htm

 

posted @ 2015-01-23 15:48  小天_y  阅读(1281)  评论(0编辑  收藏  举报