C语言求图的最短路径的两种算法（迪杰斯特拉算法与弗洛伊德算法）

时间：2025-02-12 18:20:34

  本人小白一枚~最近在学数据结构，学到了如何求图的最短路径，以此贴来记录学习成果，如有写的不当的地方还请大佬指正。

参考资料：《大话数据结构》

1、迪杰斯特拉(Dijkstra)算法：

按路径长度递增依次求最短路径的算法。

从第一个顶点V0依次求到下一个顶点的最短路径，代码及注释如下

 

 

#include<>
#define maxsize 20
#define infinity 65535
typedef char VT;
typedef int ET;
typedef struct{
	VT vex[maxsize];
	ET arc[maxsize][maxsize];
	int numv,nume;
}MGraph;
int V0=0;
void ShortPath_Dijkstra(MGraph G,int V0,int *sn,int *sw);
void CreatMGraph(MGraph *G);
 
int main(void)
{
	MGraph G;
	int i;
	CreatMGraph(&G);
	int sn[];//前驱顶点下标 
	int sw[];//最短路径和 
	ShortPath_Dijkstra(G,V0,sn,sw);
	for(i=0;i<;i++){
		printf("V%d->",sn[i]);
	}
	printf("V%d\n",-1);
	for(i=0;i<;i++){
		printf("V0到V%d的最短距离为：%d\n",i,sw[i]);
	}
	return 0;
}

void ShortPath_Dijkstra(MGraph G,int V0,int *sn,int *sw)
{
	int v,w,k,min;
	int final[];//标志数组，若顶点Vi最短路径已知，则final[i]=1;
	for(v=0;v<;v++){
		final[v]=0;
		sn[v]=0;
		sw[v]=[V0][v];
	}
	sw[V0]=0;
	final[V0]=1;
	//初始化完成，主循环开始
	for(v=1;v<;v++){   //每次循环确定V0到一个顶点的最短路径 
		min=infinity;  //初始化最小值min 
		for(w=0;w<;w++){    //遍历寻找离V0最近的点
			if(!final[w]&&sw[w]<min){   //如果Vw的最短路径还没找到且w到V0的权值比min小 
				k=w;    //k存储离V0最近的点的下边 
				min=sw[w];   //那么顶点Vw离V0更近 
			} 
		} 
		final[k]=1;  //Vk是离V0最近的点，则Vk的最短路径已经找到，所以标志改为1 
	    for(w=0;w<;w++){
	    	if(!final[w]&&(min+[k][w])<sw[w]){  
//如果顶点Vw的最短路径未确定且经过VK的路径比V0直达的路径短的话 
	    		sw[w]=min+[k][w];
	    		sn[w]=k;  //经过Vk的路径更短，则其前驱下标为k 
			}
		} 
	} 
}

void CreatMGraph(MGraph *G)
{
	int i,j,k,w;
	printf("输入顶点数和边数：\n");
	scanf("%d %d",&G->numv,&G->nume);
	//for(i=0;i<G->numv;i++){
	//	printf("请输入顶点V%d的值：\n",i);
	//	scanf("%s",&G->vex[i]);
	//}
	for(i=0;i<G->nume;i++){
		for(j=0;j<G->nume;j++){
			G->arc[i][j]=infinity;//初始化 
		}
	}
	for(k=0;k<G->nume;k++){
		printf("输入边(Vi,Vj)上的下标i与j和权w：\n");
		scanf("%d %d %d",&i,&j,&w);
		G->arc[i][j]=w;
		G->arc[j][i]=G->arc[i][j];
	}
}

此算法嵌套了两个循环，因此其时间复杂度为O{n^2}，但是每次只能求一个顶点到其余各顶点的最短路径与最短路径长度，如第一次输入V0=0，只求出了V0到V8的最短路径与最短路径长度，要求V1到V8的最短路径长度则要重新输入V0=1再次进行复杂度为O{n^2}的过程。

2、弗洛伊德(Floyd)算法

建立两个二维数组，一个存储最短路径的权值，一个存储最短路径的前驱

代码如下：

#include<>
#define maxsize 20
#define infinity 65535
typedef char VT;
typedef int ET;
typedef struct{
	VT vex[maxsize];
	ET arc[maxsize][maxsize];
	int numv,nume;
}MGraph;

void ShortestPath_Floyd(MGraph G,int pw[][],int pn[][]);
void PrintShortestPath(MGraph G,int pn[][],int pw[][]);
void CreatMGraph(MGraph *G);

int main(void)
{
	MGraph G;
	CreatMGraph(&G);
	int pn[][];//  pn[i][j]表示从Vi到Vj最短路径的Vi经过的的下一个顶点 
	int pw[][];//  pw[i][j]表示顶点Vi间与Vj最短路径的权值
	ShortestPath_Floyd(G,pn,pw);
	PrintShortestPath(G,pn,pw);
	return 0;
}

void ShortestPath_Floyd(MGraph G,int pn[][],int pw[][])  //二维数组传参时只能省略1维的大小，不能省略更高维 
{
	int v,w,k;
	for(v=0;v<;v++){
		for(w=0;w<;w++){
			pw[v][w]=[v][w];//  pw[][]初始化为各个点间的权值(无连线的两点间权值为无穷)
			pn[v][w]=w;//  初始化路径为直接到达 
		}
	}
	//初始化结束，主循环开始
	for(k=0;k<;k++){
		for(v=0;v<;v++){
			for(w=0;w<;w++){
				if(pw[v][w]>pw[v][k]+pw[k][w]){
					pw[v][w]=pw[v][k]+pw[k][w];//   权值改为更小的有转折的 
					pn[v][w]=pn[v][k];//   前驱改为k 
				}
			}
		}
	} 
}

void PrintShortestPath(MGraph G,int pn[][],int pw[][])
{
	int v,w,k;
	for(v=0;v<;v++){
		for(w=v+1;w<;w++){
			printf("V%d--V%d  weight: %d\n",v,w,pw[v][w]);
			k=pn[v][w];
			printf("path: V%d",v);  //打印源起点
			while(k!=w){
				printf("->V%d",k);
				k=pn[k][w];  //获取下一个路径起点坐标且不打印终点 
			}
			printf("->V%d\n",w);  //打印终点 
		}
	    printf("\n");
	}
}

void CreatMGraph(MGraph *G)
{
	int i,j,k,w;
	printf("输入顶点数和边数：\n");
	scanf("%d %d",&G->numv,&G->nume);
	//for(i=0;i<G->numv;i++){
	//	printf("请输入顶点V%d的值：\n",i);
	//	scanf("%s",&G->vex[i]);
	//}
	for(i=0;i<G->nume;i++){
		for(j=0;j<G->nume;j++){
			G->arc[i][j]=infinity;//初始化 
		}
	}
	for(k=0;k<G->nume;k++){
		printf("输入边(Vi,Vj)上的下标i与j和权w：\n");
		scanf("%d %d %d",&i,&j,&w);
		G->arc[i][j]=w;
		G->arc[j][i]=G->arc[i][j];
	}
}

Floyd算法显然比Dijkstra算法简洁很多，但是因为其初始化为两重循环，权值修正为三重循环，因此其时间复杂度为O{n^3}，真令人遗憾，不过这一算法可以一下子求出来所有顶点到其他顶点的最短路径与最小权值，当遇到要求所有顶点到其他顶点的最短路径与最小权值的问题时，这一算法一定是不错的选择。

相关文章