图的存储结构

    本文的重点在于图的深度优先搜索（DFS）和广度优先搜索（BFS），因此不再对图的基本概念做过多的介绍，但是要先大致了解下图的几种常见的存储结构。

    邻接矩阵

    邻接矩阵既可以用来存储无向图，也可以用来存储有向图。该结构实际上就是用一个二维数组（邻接矩阵）来存储顶点的信息和顶点之间的关系（有向图的弧或无向图的边）。其描述形式如下：

[cpp] view plaincopy

1. //图的邻接矩阵存储表示  
2. #define MAX_NUM 20 // 最大顶点个数  
3. enum GraphKind{GY,GN}; // {有向图,无向图}  
4. typedef struct  
5. {  
6.    VRType adj; // 顶点关系类型。对无权图，用1(是)或0(否)表示是否相邻；对带权图，则为权值  
7.    InfoType *info; // 与该弧或边相关信息的指针(可无)  
8. }ArcCell,AdjMatrix[MAX_NUM][MAX_NUM]; // 二维数组  
9. typedef struct  
10. {  
11.    VertexType vexs[MAX_NUM]; // 顶点向量  
12.    AdjMatrix arcs; // 邻接矩阵  
13.    int vexnum,arcnum; // 图的当前顶点数和弧（边）数  
14.    GraphKind kind; // 图的种类标志  
15. }Graph;  

[cpp] view plaincopy

1. //图的邻接表存储表示  
2. #define MAX_NUM 20  
3. enum GraphKind{GY,GN}; // {有向图,无向图}  
4. typedef struct   
5. {  
6.    int adjvex; // 该弧所指向的顶点或边的另一个顶点的位置  
7.    ArcNode *nextarc; // 指向下一条弧或边的指针  
8.    InfoType *info; // 与弧或边相关信息的指针（可无）  
9. }ArcNode;// 表结点  
10. typedef struct  
11. {  
12.    VertexType data; // 顶点信息  
13.    ArcNode *firstarc; // 第一个表结点的地址,指向第一条依附该顶点的弧或边的指针  
14. }VNode,AdjList[MAX_NUM]; // 头结点  
15. struct   
16. {  
17.    AdjList vertices;  
18.    int vexnum,arcnum; // 图的当前顶点数和弧（边）数  
19.    GraphKind kind; // 图的种类标志  
20. }Graph;  

[cpp] view plaincopy

1. //有向图的十字链表存储表示  
2. #define MAX_NUM 20  
3. typedef struct // 弧结点  
4. {  
5.   int tailvex,headvex; // 该弧的尾和头顶点的位置  
6.   ArcBox *hlink,*tlink; // 分别为弧头相同和弧尾相同的弧的链域  
7.   InfoType *info; // 该弧相关信息的指针，可指向权值或其他信息（可无）  
8. }ArcBox;  
9. typedef struct // 顶点结点  
10. {  
11.   VertexType data;  
12.   ArcBox *firstin,*firstout; // 分别指向该顶点第一条入弧和出弧  
13. }VexNode;  
14. struct  
15. {  
16.   VexNode xlist[MAX_NUM]; // 表头向量(数组)  
17.   int vexnum,arcnum; // 有向图的当前顶点数和弧数  
18. }Graph;      

[cpp] view plaincopy

1. //无向图的邻接多重表存储表示  
2.  #define MAX_NUM 20  
3.  typedef struct   
4.  {  
5.    VisitIf mark; // 访问标记  
6.    int ivex,jvex; // 该边依附的两个顶点的位置  
7.    EBox *ilink,*jlink; // 分别指向依附这两个顶点的下一条边  
8.    InfoType *info; // 该边信息指针，可指向权值或其他信息  
9.  }EBox;  
10.  typedef struct  
11.  {  
12.    VertexType data;  
13.    EBox *firstedge; // 指向第一条依附该顶点的边  
14.  }VexBox;  
15.  typedef struct   
16.  {  
17.    VexBox adjmulist[MAX_NUM];  
18.    int vexnum,edgenum; // 无向图的当前顶点数和边数  
19.  }Graph;  

图的遍历

    图的遍历比树的遍历要复杂的多，因为图的任一顶点都有可能与其他的顶点相邻接，因此，我们需要设置一个辅助数组visited[]来标记某个节点是否已经被访问过。图的遍历通常有两种方法：深度优先遍历（BFS）和广度优先遍历（DFS），两种遍历方式的思想都不难理解。下面我们就以如下图所示的例子来说明图的这两种遍历方式的基本思想，并用邻接表作为图的存储结构，给出BFS和DFS的实现代码（下图为无向图，有向图的BFS和DFS实现代码与无向图的相同）：

    我们以邻接表作为上图的存储结构，并将A、B、C、D、E、F、G、H在顶点数组中的序号分别设为0、1、2、3、4、5、6、7。我们根据上图所包含的信息，精简了邻接表的存储结构，采取如下所示的结构来存储图中顶点和边的相关信息：

[cpp] view plaincopy

1. #define NUM 8          //图中顶点的个数  
2.   
3. /* 
4. 用邻接表作为图的存储结构 
5. 在邻接表中，用一个一维数组存储图中的每个顶点的信息， 
6. 同时为每个顶点建立一个单链表，链表中的节点保存依附在该顶点上的边或弧的信息 
7. */  
8. typedef struct node  
9. {   //链表中的每个节点，保存依附在该节点上的边或弧的信息  
10.     int vertex;          //在有向图中表示该弧所指向的顶点（即弧头）的位置，  
11.                          //在无向图中表示依附在该边上的另一个顶点的位置  
12.     struct node *pNext;  //指向下一条依附在该顶点上的弧或边  
13. }Node;  
14. typedef struct head  
15. {   //数组中的每个元素，保存图中每个顶点的相关信息  
16.     char data;          //顶点的数据域  
17.     Node *first;        //在有向图中，指向以该顶点为弧尾的第一条弧  
18.                         //在无向图中，指向依附在该顶点上的第一条边  
19. }Head,*Graph;           //动态分配数组保存每个顶点的相关信息  

    那么用邻接表来表示上图中各顶点间的关系，如下图所示：

    深度优先搜索

    结合上面的例子来分析，假设从A点开始遍历该图，根据图中顶点的存储关系，会按照下面的步骤来遍历该图：

    1、在访问完顶点A后，选择A的第一个邻接点B进行访问；

    2、而后看B的邻接点，由于B的第一个邻接点A已经被访问过，故选择其下一个邻接点D进行访问；

    3、而后看D的邻接点，由于D的第一个邻接点B已经被访问过，故选择其下一个邻接点H进行访问；

    4、而后看H的邻接点，由于H的第一个邻接点D已经被访问过，故选择其下一个邻接点E进行访问；

    5、而后看E的邻接点，由于E的第一个邻接点B已经被访问过，那么看其第二个邻接点H，也被访问过了，E的邻接点已经全部被访问过了。

    6、这时退回到上一层递归，回到顶点H，同样H的邻接点也都被访问完毕，再退回到D，D的邻接点也已访问完毕，再退回到B，一直退回到A；

    7、由于A的下一个邻接点C还没有被访问，因此访问C；

    8、而后看C的邻接点，由于C的第一个邻接点A已经被访问过，故选择其下一个邻接点F进行访问；

    9、而后看F的邻接点，由于F的第一个邻接点C已经被访问过，故选择其下一个邻接点G进行访问；

    10、而后看G的邻接点，由于G的临界点都已被访问完毕，因此会退到上一层递归，看F顶点；

    11、同理，由F再回退到C，再由C回退到A，这是第一层的递归，A的所有邻接点也已都被访问完毕，遍历到此结束。

    综上，上图的DFS是按照如下顺序进行的：

A->B->D->H->E->H->D->B->A->C->F->G->F->C->A

    其中，红色部分代表首次访问，在这部分顶点被访问后，我们便将visited数组的对应元素设为true，表明这些顶点已经被访问过了，因此我们可以得到深度优先搜索得到的顺序为：

A->B->D->H->E->C->F->G

    深度优先搜索的代码实现如下：

[cpp] view plaincopy

1. /* 
2. 从序号为begin的顶点出发，递归深度优先遍历连通图Gp 
3. */  
4. void DFS(Graph Gp, int begin)  
5. {  
6.     //遍历输出序号为begin的顶点的数据域，并保存遍历信息  
7.     printf("%c ",Gp[begin].data);  
8.     visited[begin] = true;   
9.   
10.     //循环访问当前节点的所有邻接点（即该节点对应的链表）  
11.     int i;  
12.     for(i=first_vertex(Gp,begin); i>=0; i=next_vertex(Gp,begin,i))  
13.     {  
14.         if(!visited[i])  //对于尚未遍历的邻接节点，递归调用DFS  
15.             DFS(Gp,i);  
16.     }  
17. }   
18.   
19. /* 
20. 从序号为begin的节点开始深度优先遍历图Gp，Gp可以是连通图也可以是非连通图 
21. */  
22. void DFS_traverse(Graph Gp,int begin)  
23. {  
24.     int i;  
25.     for(i=0;i<NUM;i++)    //初始化遍历标志数组  
26.         visited[i] = false;   
27.   
28.     //先从序号为begin的顶点开始遍历对应的连通图  
29.     DFS(Gp,begin);  
30.     //如果是非连通图，该循环保证每个极大连通子图中的顶点都能被遍历到     
31.     for(i=0;i<NUM;i++)  
32.     {         
33.         if(!visited[i])  
34.             DFS(Gp,i);  
35.     }  
36. }  

[cpp] view plaincopy

1. /* 
2. 返回图Gp中pos顶点（序号为pos的顶点）的第一个邻接顶点的序号，如果不存在，则返回-1 
3. */  
4. int first_vertex(Graph Gp,int pos)  
5. {  
6.     if(Gp[pos].first)  //如果存在邻接顶点，返回第一个邻接顶点的序号  
7.         return  Gp[pos].first->vertex;  
8.     else              //如果不存在，则返回-1  
9.         return -1;  
10. }  
11.   
12. /* 
13. cur顶点是pos顶点（cur和pos均为顶点的序号）的其中一个邻接顶点， 
14. 返回图Gp中，pos顶点的（相对于cur顶点）下一个邻接顶点的序号,如果不存在，则返回-1 
15. */  
16. int next_vertex(Graph Gp,int pos,int cur)  
17. {  
18.     Node *p = Gp[pos].first; //p初始指向顶点的第一个邻接点  
19.     //循环pos节点对应的链表，直到p指向序号为cur的邻接点  
20.     while(p->vertex != cur)  
21.         p = p->pNext;  
22.   
23.     //返回下一个节点的序号  
24.     if(p->pNext)  
25.         return p->pNext->vertex;   
26.     else   
27.         return -1;  
28. }  

    广度优先搜索

    广度优先搜索（BFS）类似于树的层序遍历（如尚未掌握图的先序遍历，请移步这里：http://blog.csdn.net/ns_code/article/details/13169703）。其基本思想是：从头图中某个顶点v出发，访问v之后，依次访问v的各个未被访问的邻接点，而后再分别从这些邻接点出发，依次访问它们的邻接点，直到图中所有与v连通的顶点都已被访问。如果当前图只是需要遍历的非连通图的一个极大连通子图，则另选其他子图中的一个顶点，重复上述遍历过程，直到该非连通图中的所有顶点都被遍历完。很明显，跟树的层序遍历一样，图的广度优先搜索要用到队列来辅助实现。

    同样以上面的例子来分析，假设从A点开始遍历该图，根据图中顶点的存储关系，会按照下面的步骤来遍历该图：

    1、在访问完顶点A后，首先访问A的第一个邻接点B，而后访问A的第二个邻接点C；

    2、再根据顺序访问B的未被访问的邻接点，先访问D，后访问E；

    3、再根据顺序访问C的未被访问的邻接点，先访问F，在访问G；

    4、而后一次访问D、E、F、G等顶点的未被访问的邻接点；

    5、D的邻接点中，只有H未被访问，因地访问H；

    6、E、F、G、H等都没有未被访问的邻接点了，遍历到此结束。

A->B->C->D->E->F->G->H

    深度优先搜索的代码实现如下：

[cpp] view plaincopy

1. /* 
2. 从序号为begin的顶点开始，广度优先遍历图Gp，Gp可以是连通图也可以是非连通图 
3. */  
4. void BFS_traverse(Graph Gp,int begin)  
5. {  
6.     int i;  
7.     for(i=0;i<NUM;i++)    //初始化遍历标志数组  
8.         visited[i] = false;  
9.   
10.     //先从序号为begin的顶点开始遍历对应的连通图  
11.     BFS(Gp,begin);  
12.     //如果是非连通图，该循环保证每个极大连通子图中的顶点都能被遍历到     
13.     for(i=0;i<NUM;i++)  
14.     {   if(!visited[i])  
15.             BFS(Gp,i);        
16.     }  
17. }  
18.   
19. /* 
20. 从序号为begin的顶点开始，广度优先遍历连通图Gp 
21. */  
22. void BFS(Graph Gp,int begin)  
23. {  
24.     //遍历输出序号为begin的顶点的数据域，并保存遍历信息  
25.     printf("%c ",Gp[begin].data);  
26.     visited[begin] = true;   
27.   
28.     int i;  
29.     int pVertex;  //用来保存从队列中出队的顶点的序号  
30.     PQUEUE queue = create_queue();  //创建一个空的辅助队列  
31.     en_queue(queue, begin);          //首先将序号为begin的顶点入队  
32.     while(!is_empty(queue))  
33.     {  
34.         de_queue(queue,&pVertex);  
35.         //循环遍历，访问完pVertex顶点的所有邻接顶点,并将访问后的邻接顶点入队  
36.         for(i=first_vertex(Gp,pVertex); i>=0; i=next_vertex(Gp,pVertex,i))  
37.         {  
38.             if(!visited[i])  
39.             {  
40.                 printf("%c ",Gp[i].data);  
41.                 visited[i] = true;  
42.                 en_queue(queue,i);  
43.             }  
44.         }  
45.     }  
46.     //销毁队列，释放其对应的内存  
47.     destroy_queue(queue);  
48. }  

遍历结果

    按照上面的例子来构建图，而后采用如下代码测试DFS和BFS的输出结果：

[cpp] view plaincopy

1. /********************************** 
2. 图的BFS和DFS 
3. Author:兰亭风雨 Date:2014-02-20 
4. Email:zyb_maodun@163.com 
5. **********************************/  
6. #include<stdio.h>  
7. #include<stdlib.h>  
8. #include "data_structure.h"  
9.   
10. int main()  
11. {  
12.     Graph Gp = create_graph();  
13.   
14.     //深度优先遍历  
15.     printf("对图进行深度优先遍历：\n");  
16.     printf("从顶点A出发DFS的结果：");  
17.     DFS_traverse(Gp,0);  
18.     printf("\n");  
19.     printf("从顶点H出发DFS的结果：");  
20.     DFS_traverse(Gp,7);  
21.     printf("\n");  
22.     printf("从顶点E出发DFS的结果：");  
23.     DFS_traverse(Gp,4);  
24.     printf("\n");  
25.     printf("\n");  
26.   
27.     //广度优先遍历  
28.     printf("对图进行深度优先遍历：\n");  
29.     printf("从顶点A出发BFS的结果：");  
30.     BFS_traverse(Gp,0);  
31.     printf("\n");  
32.     printf("从顶点H出发BFS的结果：");  
33.     BFS_traverse(Gp,7);  
34.     printf("\n");  
35.     printf("从顶点E出发BFS的结果：");  
36.     BFS_traverse(Gp,4);  
37.     printf("\n");  
38.   
39.     int i;  
40.     //释放掉为每个单链表所分配的内存  
41.     for(i=0;i<NUM;i++)  
42.     {  
43.         free(Gp[i].first);  
44.         Gp[i].first = 0;  //防止悬垂指针的产生  
45.     }  
46.   
47.     //释放掉为顶点数组所分配的内存  
48.     free(Gp);  
49.     Gp = 0;  
50.     return 0;  
51. }  

完整代码下载

    完整的C语言实现代码下载地址：http://download.csdn.net/detail/mmc_maodun/6946859

本文地址：http://blog.csdn.net/ns_code/article/details/19617187