Dijkstra算法 ---求最短路径

Dijkstra算法是一个经典的算法——他是荷兰计算机科学家Dijkstra于1959年提出的单源图最短路径算法，也是一个经典的贪心算法。所谓单源图 是规定一个起点的图，我们的最短路径都是从这个起点出发计算的。算法的适用范围是一个无向（或者有向图），所有边权都是非负数。

算法描述：

节点集合V = {}空集合，距离初始化。
节点编号0..n – 1, 起点编号0≤ s < n。

距离数组

起点 d[s] = 0
其他 d[i] = ∞, 0 ≤ i < n,  i ≠ s。

循环n次

找到节点i 不属于 V，且d[i]值最小的节点i。

V = V + i

对所有满足j  V的边(i, j) 更新d[j] = min(d[j] , d[i] + w(i,  j))。

以下图为例，描述Dijkstra算法的运行过程：

初始，求A点到其他点的最短路径（也称单源最短路径）。

初始化A点

A点有3条边，AB（17），AE（16），AF（1）。

将3条边加入优先队列，此时队列中的元素为（只记录目标点）：

{1 F} | {16 E} | {17 B}

取出队列中最小的元素，{1 F}，F点是一个未处理过的点，因此得到了A点到F点的最短距离。更新距离，变为：

处理F点，F点有4条边。FA（1），FB（11），FD（14），FE（33）。其中FA已经处理过，所以忽略掉。

将3条边加入优先队列，注意，此时加入队列时，所有边的权值需要加上F点到A点的最短距离1。此时队列中的元素为：

{12 B} | {15 D}  | {16 E} | {17 B} | {34 E}

取出队列中最小的元素，{12 B}，B点是一个未处理过的点，因此得到了A点到B点的最短距离。更新距离，变为：

处理B点，B点有4条边。AB（17），BF（11），BC（6），BD（5）。其中AB，BF已经处理过，所以忽略掉。

将2条的权值加上A到B的最短路径12，加入优先队列。此时队列中的元素为：


{15 D}  | {16 E} | {17 B} | {17 D} | {18 C} | {34 E}


取出队列中最小的元素，{15 D}，D点是一个未处理过的点，因此得到了A点到D点的最短距离。更新距离，变为：

处理D点，D点有4条边。其中DC（10），DE（4）没有处理过。

将2条的权值加上A到D的最短路径15，加入优先队列。此时队列中的元素为：

{16 E} | {17 B} | {17 D} | {18 C} | {19 E} | {25 C} | {34 E}

取出队列中最小的元素，{16 E}，E点是一个未处理过的点，因此得到了A点到E点的最短距离。更新距离，变为：

处理E点，E点所连接的边都已经被处理过了。

此时优先队列中的元素为：

{17 B} | {17 D} | {18 C} | {19 E} | {25 C} | {34 E}

取出队列中最小的元素，{17 B}，B点是一个已经处理过的点，因此继续后面的处理。

 {17 D} | {18 C} | {19 E} | {25 C} | {34 E}

取出队列中最小的元素，{17 D}，D点是一个已经处理过的点，因此继续后面的处理。

 {18 C} | {19 E} | {25 C} | {34 E}

取出队列中最小的元素，{18 C}，C点是一个未处理过的点，因此得到了A点到C点的最短距离。更新距离，变为：

代码示例：

/*通过邻接矩阵来说明迪杰斯特拉算法*/

#define MAXV 10
#define INFINITY 65535

typedef struct _Graph{
	int vertex_num;
	int edge_num;
	char vertex[MAXV];
	int edges[MAXV][MAXV];
}Graph;

typedef struct _EdgeData{
	char start;
	char end;
	int weight;
}EdgeData;

/*
startVertex -- 起始顶点;
dist -- 长度数组，即dist[i]是"顶点startVertex"到"顶点i"的最短路径的长度;
*/
void Dijkstra(Graph *graph,int startVertex,int dist[]){
	
	int visited[MAXV];
	int i,j,k,min,temp;
	
	//初始化起始点到其他各个顶点的距离
	for(i=0;i<graph->vertex_num;i++}{
		if(i==startVertex){
			visited[startVertex]=1;
			dist[startVertex]=0;
		}
		else{
			visited[i]=0;
			dist[i]=graph->edges[startVertex][i];
		}
	}
	
	for(i=1;i<graph->vertex_num;i++){
		
		min=INFINITY;
		
		//在未被访问的顶点中，找到离起点最近的顶点k
		for(j=0;j<graph->vertex_num;j++){	
			if(visited[j]==0&&dist[j]<min&&dist[j]!=INFINITY){
				min=dist[i];
				k=j;
			}
		}
		
		//将顶点k标记为已访问过
		visited[k]=1;
		
		//更新未访问的顶点距起始顶点的最短路径的距离，其实就是更新k点的邻接点到起始点的距离
		for(j=0;j<graph->vertex_num;j++){
			if(graph->edges[k][j]!=INFINITY){
				temp=min+graph->edges[k][j];
				if(visited[j]==0&&temp<dist[j]){
					dist[j]=temp;
				}
			}	
		}
	}
	
	printf("Dijkstra %c : \n",graph->vertex[startVertex]);
	for(i=0;i<graph->vertex_num;i++){
		printf("Shortest (%c,%c)= %d \n",graph->vertex[startVertex],graph->vertex[i],dist[i]);
	}
}