C语言基本数据结构之三（图的广度及深度遍历，求单源最短路径的Dijkstra算法）

上一篇主要讲了二叉树的先序，中序，后序遍历算法以及深度和节点的算法，这篇就讲一讲图的基本算法。

一、图的基本概念

1.1有向图G1：

有向图G是由两个集合V(G)和E(G)组成的，其中：V(G)是顶点的非空有限集，E(G)是有向边（也称弧）的有限集合，弧是顶点的有序对，记为，v,w是顶点，v为弧尾，w为弧头，（v,w)!=(w,v)。

1.2无向图G2：

无向图G是由两个集合V(G)和E(G)组成的，其中：V(G)是顶点的非空有限集，E(G)是边的有限集合，边是顶点的无序对，记为（v,w）或（w,v)，并且（v,w)=(w,v)。

二、图的存储结构(以无向图G1为例)

2.1邻接矩阵（关联矩阵、关系矩阵）

特点：由上述可知，无向图或网络的邻接矩阵是对称的。并且，该法比较简单，用一个二维数组就可存储。
缺点：浪费空间，可用处理“稀疏”矩阵的方式去处理。

   

2.2邻接表G1

邻接表是图的一种链式存储结构。在邻接表中，对图中的每个结点建立一个单链表。第i个单链表中的结点表示依附于顶点Vi的边（有向图中指以Vi为尾的弧）. 

在边少的情况下，用邻接表比邻接矩阵节省存储空间。

三、图的遍历

3.1深度优先遍历

从图的某一顶点V0出发，访问此顶点；然后依次从V0的未被访问的邻接点出发，深度优先遍历图，直至图中所有和V0相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未被访问的顶点作起点，重复上述过程，直至图中所有顶点都被访问为止。

上图遍历结果为：V1 --> V2 --> V4 --> V8 --> V5 --> V3 --> V6 --> V7

3.2广度优先遍历

从图的某一顶点V0出发，访问此顶点后，依次访问V0的各个未曾访问过的邻接点；然后分别从这些邻接点出发，广度优先遍历图，直至图中所有已被访问的顶点的邻接点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未被访问的顶点作起点，重复上述过程，直至图中所有顶点都被访问为止。

上图遍历结果为：V1 --> V2 --> V3 --> V4 --> V5 --> V6 --> V7 --> V8

四、迪杰斯特拉算法求单源最短路径（Dijkstra）

算法描述；

1）设A[1..n,1..n]为有向图的带权邻接矩阵，A[i,j]表示弧(Vi,Vj)上的权值，若(Vi,Vj)不存在，则A[i,j]为无穷大；S 为已找到从源点V0出发的最短路径的终点集合，初始状态为{V0}；DIST[1..n]为个终点当前找到的最短路径长度，初始值为DIST[i]=A[V0,i]；

2）选择u，使DIST[u]=min{DIST[w]|w!∈S,w∈V}, S=S∪{u},其中，V为有向图的顶点集合；

3）对于所有不在S中终点w，若 DIST[u]+A[u,w] < DIST[w], 则修改DIST[w]为 DIST[w]=DIST[u]+A[u,w]；

4）重复操作2）、3）共n-1次，由此可求得从V0到各终点的最短路径。

五、代码分析

把基本概念讲解后，我们来看看代码的实现，注释都比较清楚，我就不一一讲解了

#include 
#include 
#define MAX 1000//表示两顶点间无连接
#define VN 5//顶点数
typedef struct GLink GLink;
/*
初始化邻接矩阵（图）
*/
int G[VN][VN] = {
		0,9,6,3,MAX,
		9,0,4,5,MAX,
		6,4,0,MAX,7,
		3,5,MAX,0,8,
		MAX,MAX,7,8,MAX
		};
/*
邻接表的node
*/
struct GLink{
	int adjvex;//下标
	int weight;//权值
	GLink *next;//邻接表node的下一个顶点
};
GLink *GL[VN];/*存储所有的顶点*/
int visit[VN];/*存储已经遍历的顶点*/

/*
将上面的邻接矩阵转化为邻接表
*/
void createGLink(int G[VN][VN]){
	int i,j;
	GLink *q,*p;
	for(i = 0;i 0) && (G[i][j] < MAX)){	//存在有效路径
				p = (GLink * ) malloc(sizeof( GLink));
				p->adjvex = j;/*获取顶点的下标*/	
				p->weight = G[i][j];/*获取顶点的权值*/
				if(NULL==GL[i])
					GL[i] = p;
				else
					q->next = p;
				q = p;
			}
		}
		q->next = NULL;
	}
}
/*
深度遍历优先
*/
void DFS(GLink *G[VN],int v){
	GLink *p;
	p = G[v];
	printf("[ %d ]  ",(v+1));
	visit[v] = 1;
	while(NULL != p){
		//printf("第 %d 个顶点 到第 %d 个顶点的权值为: %d \n",(v+1),(p->adjvex + 1),p->weight);
		if ((visit[p->adjvex] != 1)){
			DFS(G,p->adjvex);
		}
		p = p->next;
	}
	//printf(" 第 %d 个顶点完成遍历\n ",(v+1));
}
/*
广度遍历优先
*/
void BFS(GLink *G[VN],int v){
	int i,n = 0;//n 是获取队列中的顶点
	GLink *p;
	int Q[VN];//存放已经访问过的顶点
	//初始化队列
	for(i = 0;i < VN;i++){
		Q[i] = MAX;
	}
	visit[v] = 1;
	Q[0] = v;
	int k = 1;//当前队列中的顶点数
	printf("[ %d ]  ",(v+1));
	while((kadjvex + 1),p->weight);
			if(visit[p->adjvex] != 1){
				printf("[ %d ]  ",(p->adjvex+1));
				//将访问过的顶点入队
				Q[k] = p->adjvex; 
				//修改为访问过
				visit[p->adjvex] = 1;
				k++;
				}
			p = p->next;
		}
	}
}
/*
根据Dijkstra算法求出单元最短路径   v是起始点
*/
void Short(int G[VN][VN],int v){
	int Dist[VN];//两点之间的最短距离

	int Path[VN];//存储的路径
	
	int final[VN];//已经找到的最短路径顶点

	int i ,j ;//外部和内部循环
	/*
	存储v顶点到其他顶点之间的距离，默认为这两点之间的最短距离
	*/
	for(i = 0; i < VN ; i++){

		final[i] = 0;//将final初始化，表示没有一个顶点找到了最短路径

		Dist[i] = G[v][i];//存储距离
		if(Dist[i] < MAX)
			Path[i] = v;//v点到i点的路径有效，存储该路径v
	}
	final[v] = 1;//标记为最短路径
	int min,k;
	for(i = 0;i < VN;i++){
		min = MAX;//获取最短路径
		k = v;
		//获取距离v点最短的顶点
		for(j = 0;j < VN ; j++){
			//v -> i 如果存在有效路径，并且小于当前的最小距离
			if( (final[i] != 1) && (Dist[i] < min) &&(Dist[i] != 0 )){
				k = i;
				min = Dist[i];
			}
		}
		final[k] = 1;//k点离v点最近,将k 点保存在final中
		/*
		在v点到j点路径上，如果存在该点k ，使得v->k->j的距离小于v->j 的距离
		*/
		for(j = 0;j < VN ; j++){
			if((final[j] != 1) && (Dist[k] + G[k][j] < Dist[j] )){
				Dist[j] = Dist[k] + G[k][j];
				Path[j] = k;//存储该k点
			}
		}
	}
	/*
	打印出v点到其他顶点的最短路径及距离
	*/
	for(i = 0 ;i < VN ; i++){
		if(final[i]!=0){
			k = i;
			while( k != v){
				printf(" %d <- ",k);	
				k = Path[k];
			}
			printf(" %d ",v);
			printf(" \nshortPath is %d \n\n",Dist[i]);
		}
		else
			printf(" the Vertex %d no shortPah \n ",i);
	}
}
void main(){
	int i ;
	for(i = 0 ;i < VN;i++){
		GL[i] = NULL;
	}
	i =0;
	createGLink(G);
	printf("深度优先遍历\n ");
	DFS(GL,0);
	for(i = 0;i < VN ;i ++){
		visit[i] = 0;
	}
	printf("\n\n\n广度优先遍历\n");
	BFS(GL,0);
	printf(" \n\n\n最短路径算法\n");
	Short(G,1);
}

V1Þ V2ÞV3Þ V4ÞV5ÞV6ÞV7ÞV8