C语言-最短路径（Dijskra算法）

最新推荐文章于 2023-06-04 18:03:53 发布

Attract1206

最新推荐文章于 2023-06-04 18:03:53 发布

阅读量1.4w

点赞数 56

分类专栏：数据结构文章标签：数据结构算法 c语言图论

本文链接：https://blog.csdn.net/Attract1206/article/details/106841002

版权

数据结构专栏收录该内容

28 篇文章 52 订阅

订阅专栏

顶点下标查找函数（LocateVex）
创建有向网（CreateDN）
打印图函数（print）
展示最短路径函数（displayPath）
查找当前最短路径函数（FindMinDist）
迪杰斯特拉算法（ShortestPath_Dijkstra）

单源点最短路径

什么叫单源点最短路径？

单源点指的就是单一的起始点，那么单源点最短路径指的就是，从单一起始点到其余顶点的最短路径。

网图与非网图的单源点最短路径

对于非网图而言，最短路径表示的是由起始点到终点需要经过的最少路径条数
对于网图而言，最短路径表示的是由起始点到终点，所需花费的最少代价，也就是路径权值总和最小

最短路径算法

对于网（带权图）而言，求两点之间的最短路径有两种算法：迪杰斯特拉（Dijkstra算法）和弗洛伊德（Floyd算法）

单源最短路径—迪杰斯特拉算法：从一个起始点出发，到达一个终点
多源最短路径—弗洛伊德算法：求每一对顶点之间的最短路径

Prim算法与Dijskra算法的同异之处

迪杰斯特拉算法处处可见普里姆算法的影子，大体上两者都是在寻找当前情况下的最短边，而不同之处在于，迪杰斯特拉算法做了路程的累加（见下代码第42-46行）。

void ShortestPath_Dijkstra(MGraph *G,VertexType start)
{
	int i,j,num;
	int loc;
	int min;
	int dist[VertexMax];//最短路径长度数组 
	int path[VertexMax];//最短路径数组 
	int s[VertexMax];//代表集合S（1代表该顶点已处理，属于集合S；0代表该顶点未处理，不属于集合S，属于集合V-S） 
	
	//1.初始化dist和path数组 
	loc=LocateVex(G,start);//获取源点的下标位置 
	for(i=0;i<G->vexnum;i++)
	{
		dist[i]=G->AdjMatrix[loc][i];//初始化dist数组
		
		if(dist[i]!=MaxInt)//初始化path数组
		{
			path[i]=loc;
		}
		else
		{
			path[i]=-1;
		}	  
	} 
    
    //2.初始化S数组（s数组：代表集合S，1代表该元素属于集合S(已处理的顶点)，0该元素不属于集合S(未处理的顶点)） 
    for(i=0;i<G->vexnum;i++)
	{
		s[i]=0;
	} 
	s[loc]=1;//代表起始点(源点)以处理完毕 
	num=1;
	
	//3.
	while(num<G->vexnum)
	{
		min=FindMinDist(dist,s,G->vexnum);//在dist数组中查找其对应s[i]=0，即未处理的最小值元素 
		s[min]=1;//将找到的最短边所对应的的顶点加入集合S
		
		for(i=0;i<G->vexnum;i++)//加入新的顶点后，更新dist和path数组 
		{
			if((s[i]==0)&&(dist[i]>dist[min]+G->AdjMatrix[min][i]))//路径累加
			{
				dist[i]=dist[min]+G->AdjMatrix[min][i];
				path[i]=min;
			}
		}
	    num++;	
	}    
}

Dijskra执行流程：

（本人懒得作图，此处借用懒猫老师文图演示）

算法步骤：

初始化：
1.1 初始化dist[i]数组
1.2 根据dist[i]数组来初始化path[i]数组
1.3 初始化S集合，也就是初始化s[i]数组
查找后续顶点，不断地累加、更新、迭代，生成最短路径。（Dijskra算法核心部分）
（注：迪杰斯特拉算法并不能直接生成最短路径，但是算法将最短路径信息保存在dist数组和path数组中。）

如何根据dist和path数组输出最短路径？

dist数组中保存的是起始点到数组下标对应顶点的路径长度（累加的结果）
path数组中保存的是对应path数组下标顶点的前驱顶点（前一个顶点）

所以我们可以将终点带入path数组中，在一步步反推回起始点，即可得到反序最短路径
此时我们再将反序最短路径放入一个数组中，在反序输出即可
具体实现于函数displayPath

完整源代码

#include <stdio.h>
#include <stdlib.h>
#define VertexMax 20 //最大顶点数为20
#define MaxInt 32767 //表示最大整数，表示 ∞ 

typedef char VertexType; //每个顶点数据类型为字符型 

typedef struct
{
	VertexType Vertex[VertexMax];//存放顶点元素的一维数组 
	int AdjMatrix[VertexMax][VertexMax];//邻接矩阵二维数组 
	int vexnum,arcnum;//图的顶点数和边数  
}MGraph;

int LocateVex(MGraph *G,VertexType v)//查找元素v在一维数组 Vertex[] 中的下标，并返回下标 
{
	int i;
	
	for(i=0;i<G->vexnum;i++)
	{
		if(v==G->Vertex[i])
		{
			return i; 
		} 
	 } 
	 
	 printf("No Such Vertex!\n");
	 return -1;
}

void CreateDN(MGraph *G) 
{
	int i,j;
	//1.输入顶点数和边数 
	printf("输入顶点个数和边数：\n");
	printf("顶点数 n="); 
	scanf("%d",&G->vexnum);
	printf("边  数 e="); 
	scanf("%d",&G->arcnum);

	//2.输入顶点元素 
	printf("输入顶点元素(无需空格隔开)：");
	scanf("%s",G->Vertex);
	printf("\n");
	//3.矩阵初始化
	for(i=0;i<G->vexnum;i++) 
	 for(j=0;j<G->vexnum;j++)
	    {
	    	G->AdjMatrix[i][j]=MaxInt;
		}
	
	 //4.构建邻接矩阵
	 int n,m;
	 VertexType v1,v2;
	 int w;//v1->v2的权值 
	 
	 printf("输入路径及路径长度：\n");
	 for(i=0;i<G->arcnum;i++)
	 {
	 	printf("输入第%d条路径信息：",i+1);
	 	scanf(" %c%c,%d",&v1,&v2,&w);
	 	n=LocateVex(G,v1); //获取v1所对应的在Vertex数组中的坐标 
	 	m=LocateVex(G,v2); //获取v2所对应的在Vertex数组中的坐标
	 	
	 	if(n==-1||m==-1)
		 {
		 	printf("NO This Vertex!\n");
		 	return;
		  } 
	
	   G->AdjMatrix[n][m]=w;
	 }
}

void print(MGraph G)
{
	int i,j;
	printf("\n-----------------------------------------------");
	printf("\n 邻接矩阵：\n\n"); 
		
		printf("\t ");
		for(i=0;i<G.vexnum;i++)
		printf("\t%c",G.Vertex[i]);
		printf("\n");
		 
		for(i=0;i<G.vexnum;i++)
	   {
	   	  printf("\t%c",G.Vertex[i]);
	   	  
		  for(j=0;j<G.vexnum;j++)
	    {
	    	
	    	if(G.AdjMatrix[i][j]==MaxInt)
	 	    printf("\t∞");
	 	    else printf("\t%d",G.AdjMatrix[i][j]);
	    }
	      printf("\n");
	   }
	 
}

void displayPath(int dist[],int path[],MGraph *G,VertexType start)
{
	int i,k,j=0;
	int temp[VertexMax];//临时数组 
	VertexType target;//目标地点 
	int loc=0; 
	
	for(i=0;i<VertexMax;i++)
	temp[i]=-1;
	
	printf("\n-----------------------------------------------\n");
	printf("结果展示：\n");
	printf("\n\n");
	//打印dist数组 
	printf("\tdist[i]:\n\t");
	for(i=0;i<G->vexnum;i++)
	printf("\t%d",i);
	printf("\n\t"); 
	  for(i=0;i<G->vexnum;i++)
    {
    	printf("\t%d",dist[i]);
	}
	printf("\n");
	
	printf("\n\n");
	//打印path数组 
	printf("\n\tpath[i]:\n\t");
	for(i=0;i<G->vexnum;i++)
	printf("\t%d",i);
	printf("\n\t"); 
	for(i=0;i<G->vexnum;i++)
    {
    	printf("\t%d",path[i]);
	}
     
    printf("\n\n"); 
	 //最短路径 
	 printf("最短路径:\n\n"); 
	for(i=0;i<G->vexnum;i++)
	{
		loc=i;
		j=0;
		while(loc!=-1)
    	{
    		temp[j]=loc;
    		loc=path[loc];
    		j++;
		}
		
		if(j-1==0&&G->Vertex[temp[j-1]]==start)
			{
				printf("\t");
				printf("%c->%c:%c为起始点!",start,G->Vertex[i],G->Vertex[temp[j-1]]);
			}
			else if(j-1==0&&G->Vertex[temp[j-1]]!=start)
			{
				printf("\t");
				printf("%c->%c:%c不可达%c",start,G->Vertex[i],start,G->Vertex[temp[j-1]]);
			}
			else
			{
				printf("\t");
				printf("%c->%c:",start,G->Vertex[i]);
				for(j=j-1;j>=0;j--)
				{
					printf("%c ",G->Vertex[temp[j]]);
				}
				printf("(总路径长度:%d)",dist[i]);
			}
	    for(k=0;k<20;k++)
	    temp[k]=-1;
	 
	 printf("\n\n"); 

	}
}

int FindMinDist(int dist[],int s[],int vexnum) 
{
	int i;
	int loc;
	int min=MaxInt+1;
	for(i=0;i<vexnum;i++)
	{
		if(s[i]==0)//只对s[i]=0的顶点进行查找 
		{
			if(dist[i]<min)
			{
				min=dist[i];
				loc=i;
			}
		}
	}
	return loc;//返回dist中最小元素的下标 
}

void ShortestPath_Dijkstra(MGraph *G,VertexType start)
{
	int i,j,num;
	int loc;
	int min;
	int dist[VertexMax];//最短路径长度数组 
	int path[VertexMax];//最短路径数组 
	int s[VertexMax];//代表集合S（1代表该顶点已处理，属于集合S；0代表该顶点未处理，不属于集合S，属于集合V-S） 
	
	//1.初始化dist和path数组 
	loc=LocateVex(G,start);//获取源点的下标位置 
	for(i=0;i<G->vexnum;i++)
	{
		dist[i]=G->AdjMatrix[loc][i];
		
		if(dist[i]!=MaxInt)
		{
			path[i]=loc;
		}
		else
		{
			path[i]=-1;
		}	  
	} 
    
    //2.初始化S数组（s数组：代表集合S，1代表该元素属于集合S(已处理的顶点)，0该元素不属于集合S(未处理的顶点)） 
    for(i=0;i<G->vexnum;i++)
	{
		s[i]=0;
	} 
	s[loc]=1;//代表起始点(源点)以处理完毕 
	num=1;
	
	//3.
	while(num<G->vexnum)
	{
		min=FindMinDist(dist,s,G->vexnum);//在dist数组中查找其对应s[i]=0，即未处理的最小值元素 
		s[min]=1;//将找到的最短边所对应的的顶点加入集合S
		
		for(i=0;i<G->vexnum;i++)//加入新的顶点后，更新dist和path数组 
		{
			if((s[i]==0)&&(dist[i]>dist[min]+G->AdjMatrix[min][i]))//
			{
				dist[i]=dist[min]+G->AdjMatrix[min][i];
				path[i]=min;//min->i
			}
		}
	    num++;	
	} 
    displayPath(dist,path,G,start);//展示dist数组、path数组及最短路径 
    
} 

int main() 
{
	MGraph G;
	VertexType start;
	
	CreateDN(&G);
	print(G); 
	
	printf("输入起始点："); 
	scanf(" %c",&start);
	printf("\n");
	ShortestPath_Dijkstra(&G,start);
	
	 
	return 0;
}

执行结果：

（建议放大查看）

参考：

懒猫老师

Attract1206

关注

56
点赞
踩
288

收藏

觉得还不错? 一键收藏
打赏
5
评论
C语言-最短路径（Dijskra算法）

1. 顶点下标查找函数（LocateVex）2. 创建有向网（CreateDN）3. 打印图函数（print）4. 展示最短路径函数（displayPath）5. 查找当前最短路径函数（FindMinDist）6. 迪杰斯特拉算法（ShortestPath_Dijkstra）
复制链接

扫一扫