迪杰斯特拉算法——最短路径

分析过程：

需要构建的有向图和最短路径
分析每次取出里面的最短路径
程序执行的过程：

代码块：

迪杰斯特拉算法 ：

#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
#define INFINITY 65535		//定义一个无限大的值 
#define MaxSize  50			//最大顶点个数 
#include <iostream>
using namespace std;
typedef char VertexType[4];
typedef char InfoPtr;
typedef int VRType;
typedef enum {DG,DN,UG,UN} GraphKind;//图的类型：有向图，有向网，无向图，无向网 
//迪杰斯特拉算法 
typedef int PathMatrix[MaxSize];//定义一个保存最短路径的一堆数组
typedef int ShortPathLength[MaxSize];//定义一个保存到从顶点v0到顶点v的最短距离的数组

typedef struct{
	VRType adj;//对于无权图，用1表示相邻。0表示不相邻；对于带权图，存储权值
	InfoPtr *info;//与弧或边相关的信息 
}ArcNode,AdjMatrix[MaxSize][MaxSize]; 
//图类型的定义 
typedef struct{
	VertexType vex[MaxSize];//用于存储顶点
	 AdjMatrix arc;//用于存储邻接矩阵的边和弧的信息 
	 int vernum,arcnum;//顶点数和边（弧）的数目
	GraphKind kind;//图的类型 
}MGraph;






//创建无向网N
void CreateGraph1(MGraph *N); 
//查找
int LocateVertex(MGraph N,VertexType v); 
//销毁
void DestroyGraph(MGraph *N);
//打印网 
void DisplayGraph(MGraph N); 
//用迪杰斯特拉算法求有向网N的v0顶点到其余各项顶点v的最短路径path[v]及带权长度dist[v] 
void Dijikstra(MGraph N,int v0,PathMatrix path,ShortPathLength dist,int final[]); 
//打印最短路径
void PrintShortPath(MGraph N,int v0,PathMatrix path,ShortPathLength dist) ;
//创建无向网N
void CreateGraph1(MGraph *N){
	int i,j ,k, w,InfoFlag,len;
	char s[MaxSize];
	VertexType v1,v2;
	printf("请输入有向网N的顶点数，弧数，弧的信息（是：1，否：0）");
	scanf("%d,%d,%d",&(*N).vernum,&(*N).arcnum,&InfoFlag);
	printf("请输入%d个顶点的值<%d个字符：\n",N->vernum,MaxSize); 
	//顶点 
	for(i=0;i<N->vernum;i++){
		printf("请输入数据：");
		scanf("%s",N->vex[i]);
	}
	//初始化邻接矩阵 
	for(i=0;i<N->vernum;i++){
		for(j=0;j<N->vernum;j++){
			N->arc[i][j].adj=INFINITY;
			N->arc[i][j].info=NULL; 
		}
	}
	printf("请输入%d条弧的弧尾  弧头  权值  （以空格作为间距）：\n",N->arcnum);
	for(k=0;k<N->arcnum;k++){
		scanf("%s%s%d",v1,v2,&w);
		i=LocateVertex(*N,v1);
		j=LocateVertex(*N,v2);
		N->arc[i][j].adj = w;
		if(InfoFlag){
			printf("请输入弧的相关信息:");
			gets(s);
			len=strlen(s);
			if(len){
				N->arc[i][j].info=(char*)malloc((len+1)*sizeof(char));
				strcpy(N->arc[i][j].info,s);
			} 
		}
	}
	N->kind=DN; 
} 

//查找 
int LocateVertex(MGraph N,VertexType v){
	int i;
	for(i=0;i<N.vernum;++i){
		if(strcmp(N.vex[i],v)==0){
			return i; 
		}
	}
	return -1;
}
//销毁网
void DestroyGraph(MGraph *N){
	int i,j;					
	//释放弧的相关信息 
	for(i=0;i<N->vernum;i++){
		for(j=0;j<N->vernum;j++){
			if(N->arc[i][j].adj!=INFINITY){
				if(N->arc[i][j].info!=NULL){	//如果存在弧 
				free(N->arc[i][j].info);	//如果弧有相关信息，释放该信息所占用的空间 
				N->arc[i][j].info=NULL;     
			} 
			} 
		}
	}
	N->vernum=0;
	N->arcnum=0;
}
//网打印  
void DisplayGraph(MGraph N) {
	int i,j;
	printf("有向网具有%d个顶点%d条弧，顶点依次是：",N.vernum,N.arcnum);
	for(i=0;i<N.vernum;++i){
		printf("%s",N.vex[i]);
	}
	printf("\n网N的;\n");
	printf("序号i=");
	for(i=0;i<N.vernum;i++)
		printf("%4d",i);
	printf("\n");
	for(i=0;i<N.vernum;i++){
		printf("%6d",i);
		for(j=0;j<N.vernum;j++){
			if(N.arc[i][j].adj<INFINITY)
				printf("%4d",N.arc[i][j].adj);
			else
			    printf("%4s","∞"); 
		}
		printf("\n");
	}
	 
}
//用迪杰斯特拉算法求有向网N的v0顶点到其余各项顶点v的最短路径path[v]及带权长度dist[v] 
void Dijikstra(MGraph N,int v0,PathMatrix path,ShortPathLength dist,int final[] ){
	int v,w,k,min;
	for(v=0;v<N.vernum;v++){//数组dist存储v0-v的最短距离，初始化为v0到v的弧的距离 
		final[v]=0;
		dist[v]=N.arc[v0][v].adj;//记录与v0有连接的顶点的权值 
		//存在路径等于0 路径不存在为-1 
		if(N.arc[v0][v].adj<INFINITY)
			path[v]=0;
		else
			path[v]=-1;   //初始化路径数组path为-1 
	}
	dist[v0]=0;//v0到v0的路径为0 
	final[v0]=1; //v0顶点并入集合S
	path[v0]=v0;
	//从v0到其余N.vernum-1个顶点的最短路径，并将该顶点并入集合
	//利用循环每次求v0到某个顶点v的最短路径
	for(v=1;v<N.vernum;v++){
		min=INFINITY;//记录一次循环距v0的距离 
		for(w=0;w<N.vernum;w++){//找出距v0最近的顶点
			//final[w]为0表示该顶点还没有记录与它最近的顶点
			if(!final[w]&&dist[w]<min){//在不属于集合S的顶点中找到离v0最近的顶点 
				k=w;  //记录最小权值的下标，将其距v0最近的顶点w赋给k 
				min=dist[w];//记录最小权值 
			} 
		} 
		//将目前找到的最接近v0的顶点的下标的位置为1，表示该顶点已被记录
		final[k]=1; //将v并入集合s
		//修正当前最短路径即距离
		for(w=0;w<N.vernum;w++){//利用新并入集合s的顶点，更新v0到不属于集合S的顶点的最短路径的长度和最短路径的数组 
			//如果经过顶点v的路径比现在这路径短，则修改v0到w的距离
			if(!final[w]&&min<INFINITY&&N.arc[k][w].adj<INFINITY&&(min+N.arc[k][w].adj<dist[w])){
				dist[w]=min+N.arc[k][w].adj;//修改顶点w距离v0的最短长度 
				path[w]=k;		//存储最短路径前驱结点的下标 
			} 
		}
	} 
}
//打印最短路径
void PrintShortPath(MGraph N,int v0,PathMatrix path,ShortPathLength dist) {
	int i,j,k=0;
	int apath[MaxSize];
	printf("存储最短路径前驱节点下标的数组path的值：\n");
	printf("数组下标：\n");
	for(i=0;i<N.vernum;i++){
		printf("%2d",i);
	}
	printf("\n数组的值:\n");
	for(i=0;i<N.vernum;i++){
		printf("%2d",path[i]);
	}
	/*存储最短路径前驱结点下标的数组path值为：
	数组下标： 0 1 2 3 4 5 
	数组的值：0 0 0 2 3 0
	当path[4]=3时表示，顶点4的前驱节点时顶点3
	找到顶点3，有path[3]=2,表示顶点3的前驱结点时顶点2
	找到顶点2，有path[2]=0; 表示顶点2的前驱结点是顶点0
	因此由顶点4到顶点0的最短路径为：
	4->3->2>->0
	将这个顺序倒过来即可得到顶点0到顶点4的最短路径 
	*/ 
	printf("\n\nv0到其他顶点的最短路径如下：\n");
	for(i=1;i<N.vernum;i++){
		k=0;
		printf("v%d->v%d",v0,i);
		j=i;
		printf("%s",N.vex[v0]);
		while(path[j]!=0){
			apath[k]=path[k];
			j=path[k];
			k++; 
		}
		for(j=k-1;j>=0;j--){
			printf("%s",N.vex[apath[j]]);
		}
		printf("%s",N.vex[i]);
		printf("\n");
	} 
	printf("\n顶点v%d到个顶点的最短路径长度为：\n",v0);
	for(i=1;i<N.vernum;i++){
		printf("%s-%s:%d\n",N.vex[i],N.vex[0],dist[i]);//dist数组中存放v0到个顶点的最短路径 
	}
}

int main(){
	MGraph N; 
	int final[MaxSize];
	PathMatrix path;
	ShortPathLength dist;
	printf("创建一个网N：\n");
	CreateGraph1(&N);
	printf("输出网的顶点和弧：\n");
	DisplayGraph(N);
	Dijikstra(N,0,path,dist,final);
	PrintShortPath(N,0,path,dist);
	printf("销毁网：\n");
	DestroyGraph(&N);
	return 1;
} 

效果图：