图的遍历 - 数据结构

图的遍历 - 数据结构 

 

概述

 

图的遍历是指从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。图的遍历操作和树的遍历操作功能相似。图的遍历是图的一种基本操作，图的其它算法如求解图的连通性问题，拓扑排序，求关键路径等都是建立在遍历算法的基础之上。

由于图结构本身的复杂性，所以图的遍历操作也较复杂，主要表现在以下四个方面：

① 在图结构中，没有一个“自然”的首结点，图中任意一个顶点都可作为第一个被访问的结点。

② 在非连通图中，从一个顶点出发，只能够访问它所在的连通分量上的所有顶点，因此，还需考虑如何选取下一个出发点以访问图中其余的连通分量。

③ 在图结构中，如果有回路存在，那么一个顶点被访问之后，有可能沿回路又回到该顶点。

④ 在图结构中，一个顶点可以和其它多个顶点相连，当这样的顶点访问过后，存在如何选取下一个要访问的顶点的问题。

图的遍历通常有深度优先搜索和广度优先搜索两种方式，他们对无向图和有向图都适用。

 

1.深度优先搜索

 

深度优先搜索（Depth_Fisrst Search）遍历类似于树的先根遍历，是树的先根遍历的推广。

 假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可从图中某个顶点发v 出发，访问此顶点，然后依次从v 的未被访问的邻接点出发深度优先遍历图，直至图中所有和v 有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。

以如下图的无向图G5为例，进行图的深度优先搜索：

G5

搜索过程：

 

假设从顶点v1 出发进行搜索，在访问了顶点v1 之后，选择邻接点v2。因为v2 未曾访问，则从v2 出发进行搜索。依次类推，接着从v4 、v8 、v5 出发进行搜索。在访问了v5 之后，由于v5 的邻接点都已被访问，则搜索回到v8。由于同样的理由，搜索继续回到v4，v2 直至v1，此时由于v1 的另一个邻接点未被访问，则搜索又从v1 到v3，再继续进行下去由此，得到的顶点访问序列为：

显然，这是一个递归的过程。为了在遍历过程中便于区分顶点是否已被访问，需附设访问标志数组visited[0:n-1], ，其初值为FALSE ，一旦某个顶点被访问，则其相应的分量置为TRUE。

1）邻接矩阵的存储方式实现：

 

[cpp] ​​view plain​​ ​​copy​​

 

 ​​print​​​​?​​

2. // stdafx.h : include file for standard system include files,  
3. // or project specific include files that are used frequently, but  
4. // are changed infrequently  
5. //  
6.   
7. #pragma once  
8.   
9. #include "targetver.h"  
10. #include <stdio.h>    
11. #include "stdlib.h"  
12. #include <iostream>  
13. using namespace std;  
14.   
15. //宏定义      
16. #define TRUE   1      
17. #define FALSE   0     
18. #define NULL 0  
19. #define OK    1      
20. #define ERROR   0    
21. #define INFEASIBLE -1      
22. #define OVERFLOW -2    
23.   
24. #define INFINITY   INT_MAX  
25. #define MAX_VERTEX_NUM 30  
26.   
27.   
28. typedef int Status   ;  
29. typedef int ElemType ;  
30. typedef int VrType  ;  
31. typedef char VertexType  ;  
32. /************************************************************************/  
33. /* 数组表示：邻接矩阵数据结构 
34. */  
35. /************************************************************************/  
36.   
37. typedef struct ArcCell{  
38.     VrType adj;                         //顶点关系类型，对无权图，0/1表示是否相邻，有权图表示权值  
39.     ArcCell  *info;                     //弧相关信息的指针  
40. }ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  
41.   
42. typedef struct{  
43.     VertexType vexs[MAX_VERTEX_NUM];   //顶点向量  
44.     AdjMatrix arcs;                    //邻接矩阵  
45.     int vexnum,arcnum;                 //图的当前顶点数和弧数  
46. }MGraph;  

 

 

[cpp] ​​view plain​​ ​​copy​​

 

 ​​print​​​​?​​

2. // Test.cpp : Defines the entry point for the console application.    
3. //    
4. #include "stdafx.h"   
5.   
6. bool visited[MAX_VERTEX_NUM];  //访问标识  
7. Status (*VisitFunc) (int v);   //函数变量  
8. /************************************************************************/  
9. /*   
10.     确定顶点v在图G的位置 
11. */  
12. /************************************************************************/  
13. int LocateVex(MGraph G,VertexType v)  
14. {  
15.     for(int i = 0; i<G.vexnum; ++i) {  
16.         if(G.vexs[i] == v) return i;//找到  
17.     }  
18.     return -1;//不存在  
19. }  
20.   
21. /************************************************************************/  
22. /*   
23.    
24. */  
25. /************************************************************************/  
26. int FirstAdjVex(MGraph G,int v)  
27. {  
28.     int i ;  
29.     for(i = 0; i<G.vexnum; i++)  
30.         if( G.arcs[v][i].adj ) return i;  
31.     if(i == (G.vexnum  -1)) return -1;  
32.     return -1;   
33.   
34. }  
35.   
36. int NextAdjVex(MGraph G,int v,int w)  
37. {  
38.     int i;  
39.     for( i = w+1; i<G.vexnum; i++)//+1  
40.         if(G.arcs[v][i].adj) return i;  
41.     if(i == (G.vexnum  -1)) return -1;  
42.     return -1;  
43.   
44. }  
45. /************************************************************************/  
46. /* 
47.  邻接矩阵的无向图的创建: 
48.  注释的代码可以动态生成图。 
49. */  
50. /************************************************************************/  
51.   
52. void CreatUDG(MGraph &G){  
53.     cout<<"创建邻接矩阵的无向图："<<endl;  
54.     int i,j,k,w;  
55.     //G5的存储：  
56.     G.arcnum = 8;  
57.     G.vexnum = 9;  
58.     for(i=0;i<G.vexnum;++i)  
59.         for(j=0;j<G.vexnum;++j) {  
60.             G.arcs[i][j].adj=0;  
61.             G.arcs[i][j].info=NULL;  
62.         }  
63.     G.vexs[0] = '1';  
64.     G.vexs[1] = '2';  
65.     G.vexs[2] = '3';  
66.     G.vexs[3] = '4';  
67.     G.vexs[4] = '5';  
68.     G.vexs[5] = '6';  
69.     G.vexs[6] = '7';  
70.     G.vexs[7] = '8';  
71.   
72.     G.arcs[0][1].adj = 1;  
73.     G.arcs[0][1].info = NULL;  
74.     G.arcs[1][0].adj = 1;  
75.     G.arcs[1][0].info = NULL;  
76.   
77.     G.arcs[1][3].adj = 1;  
78.     G.arcs[1][3].info = NULL;  
79.     G.arcs[3][1].adj = 1;  
80.     G.arcs[3][1].info = NULL;  
81.   
82.     G.arcs[3][7].adj = 1;  
83.     G.arcs[3][7].info = NULL;  
84.     G.arcs[7][3].adj = 1;  
85.     G.arcs[7][3].info = NULL;  
86.   
87.     G.arcs[7][4].adj = 1;  
88.     G.arcs[7][4].info = NULL;  
89.     G.arcs[4][7].adj = 1;  
90.     G.arcs[4][7].info = NULL;  
91.   
92.     G.arcs[4][1].adj = 1;  
93.     G.arcs[4][1].info = NULL;  
94.     G.arcs[1][4].adj = 1;  
95.     G.arcs[1][4].info = NULL;  
96.   
97.     G.arcs[0][2].adj = 1;  
98.     G.arcs[0][2].info = NULL;  
99.     G.arcs[2][0].adj = 1;  
100.     G.arcs[2][0].info = NULL;  
101.   
102.     G.arcs[2][5].adj = 1;  
103.     G.arcs[2][5].info = NULL;  
104.     G.arcs[5][2].adj = 1;  
105.     G.arcs[5][2].info = NULL;  
106.   
107.     G.arcs[5][6].adj = 1;  
108.     G.arcs[5][6].info = NULL;  
109.     G.arcs[6][5].adj = 1;  
110.     G.arcs[6][5].info = NULL;  
111.   
112.     G.arcs[6][2].adj = 1;  
113.     G.arcs[6][2].info = NULL;  
114.     G.arcs[2][6].adj = 1;  
115.     G.arcs[2][6].info = NULL;  
116.     return ;  
117.     /* 
118.     char v1,v2; 
119.     cout<<"请输入无向图顶点个数和边数:"<<endl; 
120.     cin>>G.vexnum>>G.arcnum; 
121.     cout<<"请输入"<<G.vexnum<<"个顶点的值:"<<endl; 
122.     for(i=0;i<G.vexnum;++i) cin>>G.vexs[i]; 
123.     for(i=0;i<G.vexnum;++i) 
124.         for(j=0;j<G.vexnum;++j) { 
125.             G.arcs[i][j].adj=0; 
126.             G.arcs[i][j].info=NULL; 
127.         } 
128.  
129.         for( k=1;k<=G.arcnum;++k){ 
130.             cout<<"请输入第"<<k<<"条边的两个顶点值和它们的权重："<<endl; 
131.             cin>>v1>>v2>>w; 
132.             i = LocateVex(G,v1);   j=LocateVex(G,v2);  
133.             G.arcs[i][j].adj=w; 
134.             G.arcs[j][i]=G.arcs[i][j]; 
135.         } 
136.         */  
137. }  
138. /************************************************************************/  
139. /* 有向图邻接矩阵的创建 
140. */  
141. /************************************************************************/  
142. void CreatDG(MGraph &G){  
143.     int i,j,k,w;  
144.     char v1,v2;  
145.     G.arcnum = 8;  
146.     G.vexnum = 9;  
147.     cout<<"请输入有向图顶点个数和边数:";  
148.     cin>> G.vexnum>> G.arcnum;  
149.     cout<<"请输入"<<G.vexnum<<"个顶点的值:"<<endl;  
150.     for(i=0;i<G.vexnum;++i) cin>>G.vexs[i];  
151.     for(i=0;i<G.vexnum;++i)  
152.         for(j=0;j<G.vexnum;++j) {  
153.             G.arcs[i][j].adj = 0;  
154.             G.arcs[i][j].info = NULL;  
155.         }  
156.         for( k=1;k<=G.arcnum;++k){  
157.             cout<<"请输入第"<<k<<"条边的两个顶点值和它们的权重："<<endl;  
158.             cin>>v1>>v2>>w;  
159.             i= LocateVex(G,v1);   j = LocateVex(G,v2);   
160.             G.arcs[i][j].adj = w;  
161.         }  
162. }  
163.   
164.   
165. void visitVex(MGraph G, int v){  
166.     cout<<G.vexs[v]<<" ";  
167. }  
168.   
169. /************************************************************************/  
170. /*  以V为出发点对图G 进行递归地DFS 搜索 
171. */  
172. /************************************************************************/  
173. void DFS(MGraph G,int v){  
174.     visited[v] = true;  
175.     visitVex( G,  v); //访问第v 个顶点  
176.     for(int w = FirstAdjVex(G,v); w>=0; w = NextAdjVex(G,v,w)){  
177.         if(!visited[w]) DFS(G,w); //w未访问过，递归DFS搜索  
178.   
179.     }  
180. }  
181.   
182. /************************************************************************/  
183. /*      
184. 无向图的深度遍历        
185. */  
186. /************************************************************************/  
187. void DFSTraverse(MGraph G){//  
188.     int v;  
189.     for( v = 0; v < G.vexnum; ++v) visited[v] = false;  
190.     for( v = 0; v < G.vexnum; )   
191.         if(!visited[v]) DFS( G, v); //v未访问过，从vi开始DFS搜索  
192.         ++v;//不要像书上写的那样，++v放到for语句，这样会导致多出一次访问  
193.   
194. }  
195.   
196.   
197. void printMGraph(MGraph G){  
198.     cout<<"邻接矩阵已经创建，邻接矩阵为："<<endl;  
199.     for(int i=0;i<G.vexnum;i++){  
200.         for(int j=0;j<G.vexnum;j++)  
201.             cout<<G.arcs[i][j].adj<<" ";  
202.         cout<<endl;  
203.     }  
204. }  
205.   
206.   
207. void main(){  
208.       
209.     MGraph G;  
210.   
211.     CreatUDG(G);  
212.     printMGraph(G);  
213.     cout<<"无向图邻接矩阵的深度遍历结果："<<endl;  
214.     DFSTraverse(G);  
215. }  

2） 邻接表的表示实现方式

 

 

[cpp] ​​view plain​​ ​​copy​​

 

 ​​print​​​​?​​

2. // stdafx.h : include file for standard system include files,  
3. // or project specific include files that are used frequently, but  
4. // are changed infrequently  
5. //  
6.   
7. #pragma once  
8.   
9. #include "targetver.h"  
10. #include <stdio.h>    
11. #include "stdlib.h"  
12. #include <iostream>  
13. using namespace std;  
14.   
15. //宏定义      
16. #define TRUE   1      
17. #define FALSE   0     
18. #define NULL 0  
19. #define OK    1      
20. #define ERROR   0    
21. #define INFEASIBLE -1      
22. #define OVERFLOW -2    
23.   
24. #define INFINITY   INT_MAX  
25. #define MAX_VERTEX_NUM 30  
26.   
27.   
28. typedef int Status   ;  
29. typedef int ElemType ;  
30. typedef int VrType  ;  
31. typedef char VertexType  ;  
32.   
33. /************************************************************************/  
34. /*  邻接表示的图数据结构 
35. */  
36. /************************************************************************/  
37. //定义边结点，即表节点  
38. typedef struct ArcNode   
39. {  
40.     int adjvex;             //弧所指的顶点位置  
41.     ArcNode *nextarc;       //指向下一条弧的指针  
42. }ArcNode;  
43.   
44. //定义顶点节点，即头节点  
45. typedef struct VNode    
46. {  
47.     VertexType data;        //顶点信息  
48.     ArcNode *firstarc;      //指向第一条依附该顶点的弧的指针  
49. }VNode,AdjList[MAX_VERTEX_NUM];  
50.   
51. //定义无向图     
52. typedef struct                        
53. {  
54.     AdjList vertices;  
55.     int vexnum,arcnum;   //图的当前顶点数和弧数  
56. }ALGraph;  

[cpp] ​​view plain​​ ​​copy​​

 

 ​​print​​​​?​​

2. // Test.cpp : Defines the entry point for the console application.    
3. //    
4. #include "stdafx.h"   
5.   
6. bool visited[MAX_VERTEX_NUM];  //访问标识  
7. Status (*VisitFunc) (int v);   //函数变量  
8.   
9.   
10. /************************************************************************/  
11. /* 在无向图中添加以m,n为顶点的边 
12. */  
13. /************************************************************************/  
14. void ArcAdd(ALGraph &G,int m,int n){  
15.   
16.     ArcNode *p,*h,*q;  
17.     p = new ArcNode;  
18.     p->adjvex = m;  
19.     p->nextarc = NULL;  
20.     h = q = G.vertices[n].firstarc;  
21.     if(q == NULL)  
22.         G.vertices[n].firstarc = p;  
23.     else {   
24.         if((p->adjvex)>(q->adjvex)){   
25.             p->nextarc = q;  
26.             G.vertices[n].firstarc = p;  
27.         }  
28.         else {   
29.             while( G.vertices[n].firstarc != NULL && q->nextarc != NULL && (p->adjvex)<(q->adjvex)){ //使邻接表中边的数据按大到小排列。    
30.                 h = q;  
31.                 q = q->nextarc;  
32.             }  
33.             if(q->nextarc == NULL&&(p->adjvex)<(q->adjvex)){    
34.                 q->nextarc = p;  
35.             }  
36.             else {    
37.                 p->nextarc = q;  
38.                 h->nextarc = p;  
39.             }  
40.         }  
41.     }  
42. }  
43. /************************************************************************/  
44. /* 
45. 创建无向图 
46. */  
47. /************************************************************************/  
48. void CreateDG(ALGraph &G){    
49.     cout<<"请输入顶点个数和边数："<<endl;  
50.     cin>> G.vexnum>> G.arcnum;  
51.     cout<<"请输入顶点值:"<<endl;  
52.     for(int i= 1; i<= G.vexnum; i++) {  
53.         char t;  
54.         cin>>t;  
55.         G.vertices[i].data = t;  
56.         G.vertices[i].firstarc = NULL;  
57.     }  
58.     int m, n;  
59.     for(int k = 1; k<=G.arcnum; k++){  
60.         cout<<"请输入第"<<k<<"条边的两个顶点:"<<endl;  
61.         cin>>m>>n;  
62.         if(m<= G.vexnum && n <= G.vexnum && m>0 && n>0){  
63.             ArcAdd(G, m, n);  
64.             ArcAdd(G, n, m);  
65.         }  
66.         else  cout<<"ERROR."<<endl;   
67.     }  
68. }  
69. /************************************************************************/  
70. /* 打印邻接表的无向图       
71. */  
72. /************************************************************************/  
73. void PrintGraph(ALGraph G)    
74. {  
75.     cout<<"无向图的创建完成,该图的邻接表表示为:"<<endl;  
76.     ArcNode *p;  
77.     for(int i=1; i<=G.vexnum; i++)  
78.     {  
79.         if(G.vertices[i].firstarc == NULL)  
80.             cout<<i<<G.vertices[i].data<<"-->NULL"<<endl;  
81.         else   
82.         {  
83.             p = G.vertices[i].firstarc;  
84.             cout<<i<<G.vertices[i].data<<"-->";  
85.             while(p->nextarc!=NULL)  
86.             {  
87.                 cout<<p->adjvex<<"-->";  
88.                 p = p->nextarc;  
89.             }  
90.             cout<<p->adjvex<<"-->NULL"<<endl;  
91.         }  
92.     }  
93. }  
94.   
95.   
96. /************************************************************************/  
97. /*     返回v的第一个邻接顶点。若顶点在G中没有邻接表顶点，则返回“空”。    
98. */  
99. /************************************************************************/  
100. int FirstAdjVex(ALGraph G,int v)  
101. {   
102.     if(G.vertices[v].firstarc)  
103.         return G.vertices[v].firstarc->adjvex;  
104.     else  
105.         return NULL;  
106. }  
107. /************************************************************************/  
108. /*    
109.   返回v的（相对于w的）下一个邻接顶点。若w是v的最后一个邻接点，则返回“回”。 
110. */  
111. /************************************************************************/  
112. int NextAdjVex(ALGraph G,int v,int w)     
113. {  
114.     ArcNode *p;  
115.     if(G.vertices[v].firstarc==NULL)  
116.         return NULL;  
117.     else {  
118.         p = G.vertices[v].firstarc;  
119.         while(p->adjvex!=w) p = p->nextarc;  
120.   
121.         if(p->nextarc == NULL) return NULL;  
122.         else  return p->nextarc->adjvex;  
123.     }  
124. }  
125.   
126.   
127.   
128. void visitVex(ALGraph G, int v){  
129.     cout<<G.vertices[v].data<<" ";  
130. }  
131.   
132. /************************************************************************/  
133. /*      
134. 无向图的深度遍历        
135. */  
136. /************************************************************************/  
137. //从第v个顶点出发递归地深度优先遍历图G  
138. void DFS(ALGraph G,int v)  
139. {  
140.     visited[v] = true;  
141.     visitVex(G, v);  
142.     for(int w = FirstAdjVex(G,v);w >= 1; w = NextAdjVex(G,v,w))  
143.         if(!visited[w]) DFS(G,w);  
144. }  
145. //对图G作深度优先遍历  
146. void DFSTraverse(ALGraph G)  
147. {   
148.     for(int v = 1; v <= G.vexnum; v++) visited[v]=false;  
149.     for(int m = 1; m <= G.vexnum; m++)  
150.         if(!visited[m]) DFS(G,m);  
151. }  
152.   
153. void main(){  
154.     ALGraph G;  
155.     CreateDG(G);  
156.     PrintGraph(G);  
157.     DFSTraverse(G);  
158. }  

 

分析上述算法，在遍历时，对图中每个顶点至多调用一次DFS 函数，因为一旦某个顶点被标志成已被访问，就不再从它出发进行搜索。因此，遍历图的过程实质上是对每个顶点查找其邻接点的过程。其耗费的时间则取决于所采用的存储结构。当用二维数组表示邻接矩阵图的存储结构时，查找每个顶点的邻接点所需时间为O(n2) ，其中n 为图中顶点数。而当以邻接表作图的存储结构时，找邻接点所需时间为O(e)，其中e 为无向图中边的数或有向图中弧的数。由此，当以邻接表作存储结构时，深度优先搜索遍历图的时间复杂度为O(n+e) 。

 

2.广度优先搜索

广度优先搜索（Breadth_First Search） 遍历类似于树的按层次遍历的过程。

 

假设从图中某顶点v 出发，在访问了v 之后依次访问v 的各个未曾访问过和邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。换句话说，广度优先搜索遍历图的过程中以v 为起始点，由近至远，依次访问和v 有路径相通且路径长度为1,2,…的顶点。

对图如下图所示无向图G5 进行广度优先搜索遍历：

广度搜索过程：

首先访问v1 和v1 的邻接点v2 和v3，然后依次访问v2 的邻接点v4 和v5 及v3 的邻接点v6 和v7，最后访问v4 的邻接点v8。由于这些顶点的邻接点均已被访问，并且图中所有顶点都被访问，由些完成了图的遍历。得到的顶点访问序列为：

 

v1→v2 →v3 →v4→ v5→ v6→ v7 →v8

和深度优先搜索类似，在遍历的过程中也需要一个访问标志数组。并且，为了顺次访问路径长度为2、3、…的顶点，需附设队列以存储已被访问的路径长度为1、2、… 的顶点。

实现：

 

[cpp] ​​view plain​​ ​​copy​​

 

 ​​print​​​​?​​

2. // stdafx.h : include file for standard system include files,  
3. // or project specific include files that are used frequently, but  
4. // are changed infrequently  
5. //  
6.   
7. #pragma once  
8.   
9. #include <stdio.h>    
10. #include "stdlib.h"  

[cpp] ​​view plain​​ ​​copy​​

 

 ​​print​​​​?​​

2. // func.h :  
3. #pragma once  
4.   
5. #include <iostream>  
6. using namespace std;  
7.   
8. //宏定义      
9. #define TRUE   1      
10. #define FALSE   0     
11. #define NULL 0  
12. #define OK    1      
13. #define ERROR   0    
14. #define INFEASIBLE -1      
15. #define OVERFLOW -2    
16.   
17. #define INFINITY   INT_MAX  
18. #define MAX_VERTEX_NUM 30  
19.   
20.   
21. typedef int Status   ;  
22. typedef int ElemType ;  
23. typedef int VrType  ;  
24. typedef char VertexType  ;  
25.   
26. /************************************************************************/  
27. /*  邻接表示的图数据结构 
28. */  
29. /************************************************************************/  
30. //定义边结点  
31. typedef struct ArcNode   
32. {  
33.     int adjvex;             //弧所指的顶点位置  
34.     ArcNode *nextarc;       //指向下一条弧的指针  
35. }ArcNode;  
36.   
37. //定义顶点结点  
38. typedef struct VNode    
39. {  
40.     VertexType data;        //顶点信息  
41.     ArcNode *firstarc;      //指向第一条依附该顶点的弧的指针  
42. }VNode,AdjList[MAX_VERTEX_NUM];  
43.   
44. //定义无向图     
45. typedef struct                        
46. {  
47.     AdjList vertices;  
48.     int vexnum,arcnum;   //图的当前顶点数和弧数  
49. }ALGraph;  
50.   
51.   
52. /************************************************************************/  
53. /* 需要                                                                     */  
54. /************************************************************************/  
55. typedef struct node //定义结点  
56. {  
57.     char data;  
58.     node *next;  
59. }*Link;  
60.   
61. typedef struct //定义链表  
62. {  
63.     Link head,tail;  
64.     int len;  
65. }Queue;  
66.   
67. /************************************************************************/  
68. /* 构造一个带头结点和尾结点的空的线性链表队列Q 
69. */  
70. /************************************************************************/  
71. Status InitQueue(Queue &Q)  
72. {  
73.     Q.head = new node;  
74.     Q.head->next = Q.tail = new node;  
75.     Q.tail->next = NULL;  
76.     Q.len = 0;  
77.     return 0;  
78. }  
79.   
80. /************************************************************************/  
81. /*  
82.  //在线性链表的队列L的结尾添加一个结点 
83. */  
84. /************************************************************************/  
85.  void EnQueue(Queue &Q,int e)  
86. {  
87.     Link q = new node;  
88.     Q.tail->next = q;  
89.     Q.tail->data = e;  
90.     Q.tail = q;  
91.     Q.tail->next = NULL;  
92.     Q.len++;  
93. }  
94. /************************************************************************/  
95. /* 出列，并将出列的元素值用e返回 
96. */  
97. /************************************************************************/  
98. void DeleteQueue(Queue &Q,int &e)  
99. {  
100.     if(Q.head->next == Q.tail) {  
101.         cout<<"队列为空"<<endl;  
102.         e = NULL;  
103.     } else {  
104.         Link p,q;  
105.         p = Q.head->next;  
106.         q = p->next;  
107.         Q.head->next = q;  
108.         e = p->data;  
109.         delete p;  
110.         Q.len--;  
111.     }  
112. }  

[cpp] ​​view plain​​ ​​copy​​

 

 ​​print​​​​?​​

2. // Test.cpp : Defines the entry point for the console application.    
3. //    
4. #include "stdafx.h"   
5. #include "func.h"  
6. bool visited[MAX_VERTEX_NUM];  //访问标识  
7. Status (*VisitFunc) (int v);   //函数变量  
8.   
9. /************************************************************************/  
10. /* 在无向图中添加以m,n为顶点的边 
11. */  
12. /************************************************************************/  
13. void ArcAdd(ALGraph &G,int m,int n){  
14.   
15.     ArcNode *p,*h,*q;  
16.     p = new ArcNode;  
17.     p->adjvex = m;  
18.     p->nextarc = NULL;  
19.     h = q = G.vertices[n].firstarc;  
20.     if(q == NULL)  
21.         G.vertices[n].firstarc = p;  
22.     else {   
23.         if((p->adjvex)>(q->adjvex)){   
24.             p->nextarc = q;  
25.             G.vertices[n].firstarc = p;  
26.         }  
27.         else {   
28.             while( G.vertices[n].firstarc != NULL && q->nextarc != NULL && (p->adjvex)<(q->adjvex)){   
29.                 //使邻接表中边的数据按大到小排列。    
30.                 h = q;  
31.                 q = q->nextarc;  
32.             }  
33.             if(q->nextarc == NULL&&(p->adjvex)<(q->adjvex)){    
34.                 q->nextarc = p;  
35.             }  
36.             else {    
37.                 p->nextarc = q;  
38.                 h->nextarc = p;  
39.             }  
40.         }  
41.     }  
42. }  
43. /************************************************************************/  
44. /* 
45. 创建无向图 
46. */  
47. /************************************************************************/  
48. void CreateDG(ALGraph &G){    
49.     cout<<"请输入顶点个数和边数："<<endl;  
50.     cin>> G.vexnum>> G.arcnum;  
51.     cout<<"请输入顶点值:"<<endl;  
52.     for(int i= 1; i<= G.vexnum; i++) {  
53.         char t;  
54.         cin>>t;  
55.         G.vertices[i].data = t;  
56.         G.vertices[i].firstarc = NULL;  
57.     }  
58.     int m, n;  
59.     for(int k = 1; k<=G.arcnum; k++){  
60.         cout<<"请输入第"<<k<<"条边的两个顶点:"<<endl;  
61.         cin>>m>>n;  
62.         if(m<= G.vexnum && n <= G.vexnum && m>0 && n>0){  
63.             ArcAdd(G, m, n);  
64.             ArcAdd(G, n, m);  
65.         }  
66.         else  cout<<"ERROR."<<endl;   
67.     }  
68. }  
69.   
70. /************************************************************************/  
71. /* 打印邻接表的无向图       
72. */  
73. /************************************************************************/  
74. void PrintGraph(ALGraph G)    
75. {  
76.     cout<<"无向图的创建完成,该图的邻接表表示为:"<<endl;  
77.     ArcNode *p;  
78.     for(int i=1; i<=G.vexnum; i++)  
79.     {  
80.         if(G.vertices[i].firstarc == NULL)  
81.             cout<<i<<G.vertices[i].data<<"-->NULL"<<endl;  
82.         else   
83.         {  
84.             p = G.vertices[i].firstarc;  
85.             cout<<i<<G.vertices[i].data<<"-->";  
86.             while(p->nextarc!=NULL)  
87.             {  
88.                 cout<<p->adjvex<<"-->";  
89.                 p = p->nextarc;  
90.             }  
91.             cout<<p->adjvex<<"-->NULL"<<endl;  
92.         }  
93.     }  
94. }  
95.   
96. /************************************************************************/  
97. /*     返回v的第一个邻接顶点。若顶点在G中没有邻接表顶点，则返回“空”。    
98. */  
99. /************************************************************************/  
100. int FirstAdjVex(ALGraph G,int v)  
101. {   
102.     if(G.vertices[v].firstarc)  
103.         return G.vertices[v].firstarc->adjvex;  
104.     else  
105.         return NULL;  
106. }  
107. /************************************************************************/  
108. /*    
109.   返回v的（相对于w的）下一个邻接顶点。若w是v的最后一个邻接点，则返回“回”。 
110. */  
111. /************************************************************************/  
112. int NextAdjVex(ALGraph G,int v,int w)     
113. {  
114.     ArcNode *p;  
115.     if(G.vertices[v].firstarc==NULL)  
116.         return NULL;  
117.     else {  
118.         p = G.vertices[v].firstarc;  
119.         while(p->adjvex!=w) p = p->nextarc;  
120.   
121.         if(p->nextarc == NULL) return NULL;  
122.         else  return p->nextarc->adjvex;  
123.     }  
124. }  
125.   
126. void visitVex(ALGraph G, int v){  
127.     cout<<G.vertices[v].data<<" ";  
128. }  
129.   
130. /************************************************************************/  
131. /*      
132. 广度优先遍历图G 
133. */  
134. /************************************************************************/  
135.   
136. void BFSTraverse(ALGraph G)  
137. {  
138.     Queue Q;  
139.     int u;  
140.     for(int m=1; m<= G.vexnum; m++) visited[m] = false;  
141.     InitQueue(Q);//借助辅助队列。  
142.     for(int v=1;v<=G.vexnum;v++)  
143.         if(!visited[v]) {  
144.             visited[v]=true;  
145.             visitVex(G,v);  
146.             EnQueue(Q,v);  
147.             while(Q.len!=0)  
148.             {  
149.                 DeleteQueue(Q,u);  
150.                 for(int w=FirstAdjVex(G,u);w>=1;w=NextAdjVex(G,u,w))  
151.                     if(!visited[w])  
152.                     {  
153.                         visited[w]=true;  
154.                         visitVex(G,v);  
155.                         EnQueue(Q,w);  
156.                     }  
157.             }  
158.         }  
159.         cout<<endl;  
160. }  
161.   
162. void main(){  
163.     ALGraph G;  
164.     CreateDG(G);  
165.     PrintGraph(G);  
166.     cout<<"广度优先搜索的结果为:"<<endl;  
167.     BFSTraverse(G);  
168. }  

 

分析上述算法，每个顶点至多进一次队列。遍历图的过程实质是通过边或弧找邻接点的过程，因此广度优先搜索遍历图的时间复杂度和深度优先搜索遍历相同，两者不同之处仅仅在于对顶点访问的顺序不同。