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

已于 2022-08-21 12:11:27 修改
阅读量7.9k 收藏 113
点赞数 36
分类专栏： 数据结构
于 2020-07-02 15:38:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Attract1206/article/details/107085642
版权
  1. 顶点下标查找函数（LocateVex）
  2. 创建有向网（CreateDN）
  3. 打印图函数（print）
  4. 弗洛伊德算法（ShortestPath_Floyd）
  5. 展示最短路径（DisplayPath）

多源点最短路径

  • 多源点意为多起始点，也就是图中所有顶点都将作为起始点，求此顶点到达图中其他所有顶点的最短路径

    (未展示出不可达边！下列所有代码的测试数据均是此有向图！)
  • 在之前学习的Dijskra算法，我们知道Dijskra算法是求解单源点最短路径的算法，使用Dijskra算法可以求出一个源点到其他所有顶点的最短路径，那么我们将Dijskra算法循环执行n次（n为顶点数），每次带入图中的一个顶点，不就实现了求解多源最短路吗？
  • Dijskra算法执行单次的时间复杂度为O（n2），其中n为顶点个数，循环执行n次，那么使用Dijskra算法求解多源点最短路径的整体时间复杂度为O（n3）
  • 此次我们引入的求解多源点最短路径问题的算法是——Floyd算法，时间复杂度也为O（n3），但是在算法构造和算法可读性上优于执行n次的Dijskra算法。

Floyd算法思想

  • 弗洛伊德的核心思想是：对于网中的任意两个顶点（例如顶点 A 到顶点 B）来说，之间的最短路径不外乎有 2 种情况：
  1. 直接从顶点 A 到顶点 B 的边的权值为顶点 A 到顶点 B 的最短路径。
  2. 从顶点 A 开始，经过若干个顶点，最终达到顶点 B，期间经过的边的权值和为顶点 A 到顶点 B 的最短路径。
  • 所以，弗洛伊德算法的核心为：对于从顶点 A 到顶点 B 的最短路径，拿出网中所有的顶点进行如下判断：
    Dist（A，K）+ Dist（K，B）< Dist（A，B）
    其中，K 表示网中所有的顶点；Dist（A，B） 表示顶点 A 到顶点 B 的距离
  • 也就是说，拿出所有的顶点 K，判断经过顶点 K 是否存在一条可行路径比直达的路径的权值小，如果式子成立，说明确实存在 一条权值更小的路径，此时只需要更新记录的权值和即可。

Floyd算法

  • 本人在对书上（严蔚敏数据结构第二版C语言版）原版Floyd代码（1.0版本）的基础上，对path数组结构进行了修改，写出了后续2.0版本和3.0版本
1.0版本（书上原版）：path存储终点的前驱
int dist[VertexMax][VertexMax];
int path[VertexMax][VertexMax];

void ShortestPath_Floyd(MGraph G)
{
	int i,j,k;
    //初始化部分
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			dist[i][j]=G.AdjMatrix[i][j];
			
			if(dist[i][j]!=MaxInt)
		            {
		              	path[i][j]=i;//存入前驱 
					}
			else path[i][j]=-1;
		}
	}
	
   //Floyd算法核心部分
	for(k=0;k<G.vexnum;k++)//考虑k作为中转点
	 for(i=0;i<G.vexnum;i++)//遍历图G
	  for(j=0;j<G.vexnum;j++)
	   {
	   	    if(dist[i][j]>dist[i][k]+dist[k][j])
	   	    {
	   	    	dist[i][j]=dist[i][k]+dist[k][j];
	   	    	path[i][j]=path[k][j];//存入前驱 
			} 
       }

}
  • 此时的path数组是一个整型二维数组，存储的内容是该条路径终点的前驱顶点
  • 1.0版本的path数组存储，与Dijskra的path数组存储类型一致，都是存储前驱顶点，这样存储的结果最终是不能直接得到最短路径的，直接输出是逆序的（请看执行结果1.0），我们需要用一个数组先存储，再逆序输出。为了解决这个问题，我写出了2.0版本

2.0版本：path存储起点的后继

int dist[VertexMax][VertexMax];
int path[VertexMax][VertexMax];

void ShortestPath_Floyd(MGraph G)
{
	int i,j,k;
    //初始化部分
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			dist[i][j]=G.AdjMatrix[i][j];
			
			if(dist[i][j]!=MaxInt)
		            {
		              	path[i][j]=j;//存入后继 
					}
			else path[i][j]=-1;
		}
	}

    //算法核心部分
	for(k=0;k<G.vexnum;k++)//拿出每个顶点作为遍历条件
	 for(i=0;i<G.vexnum;i++)
	  for(j=0;j<G.vexnum;j++)
	   {
	   	    if(dist[i][j]>dist[i][k]+dist[k][j])
	   	    {
	   	    	dist[i][j]=dist[i][k]+dist[k][j];
	   	    	path[i][j]=path[i][k];//存入后继 
			} 
       }

}
  • 此时path数组仍是二维整型数组，存储的是该条路径起点的后继顶点
  • 2.0版本的path数组存储的是当前顶点的后继，那么就可以顺着起始点，顺序一个个找到终点，这种存储方式是可以顺序输出的（请看执行结果2.0）

3.0版本：在path中直接存入最短路径

int dist[VertexMax][VertexMax];
VertexType path[VertexMax][VertexMax][VertexMax]; //三维数组 

char *NewPath(char temp1[VertexMax],char temp2[VertexMax])
{
	int i=0;
	static char ch1[VertexMax],ch2[VertexMax];//要定义成静态变量
	
	for(i=0;i<VertexMax;i++)
	{
		ch1[i]=temp1[i];
		ch2[i]=temp2[i]; 
	}
	i=0;
	
    while(ch1[i]!='\0')
    {
    	i++;
	}
	
	if(ch1[i-1]!=ch2[0])
	{
		strcpy(&ch1[i],&ch2[0]);
	}
	else if(ch1[i-1]==ch2[0])
	{
		strcpy(&ch1[i-1],&ch2[0]);
	}
	
   return ch1;
}

void ShortestPath_Floyd(MGraph G)
{
	int i,j,k;
	char temp1[2]="0",temp2[2]="0";
	//初始化部分
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			dist[i][j]=G.AdjMatrix[i][j];
			
			if(dist[i][j]!=MaxInt)
		            {
		              	temp1[0]=G.Vertex[i];
		              	temp2[0]=G.Vertex[j];
		              	strcpy(path[i][j],NewPath(temp1,temp2));
					}
			else strcpy(path[i][j],"0");
		}
	}
	
	//算法核心部分
	for(k=0;k<G.vexnum;k++)//拿出每个顶点作为遍历条件
	 for(i=0;i<G.vexnum;i++)
	  for(j=0;j<G.vexnum;j++)
	   {
	   	    if(dist[i][j]>dist[i][k]+dist[k][j])
	   	    {
	   	    	dist[i][j]=dist[i][k]+dist[k][j];
	   	    	strcpy(path[i][j],NewPath(path[i][k],path[k][j]));
			} 
       }
}

  • 此时的path数组是三维字符型数组，直接存储最短路径

  • 要实现path直接存储最短路径（字符串），还需要写一个字符串合并函数NewPath，该函数实现的功能是：
    ①初始时AB之间有边，传入A、B将其合成为"AB"
    ② 后续如果有形如：AB、BC可以合成为AC

  • 需要注意的是：
    ① 初始化时，G.Vertex[i]与G.Vertex[j]，要先放入字符数组temp1和temp2，以字符串的形式传入NewPath函数
    ② 当字符数组作为函数参数传入时，只能传数组地址，意思就是，此时形参与实参同时指向同一个数组，同时发生改变，所以，要在NewPath函数内定义两个新的数组：
    static char ch1[VertexMax],ch2[VertexMax];//要定义成静态变量
    来代替作为参数传入的数组进行操作。

总结：

  1. 三个版本的代码思路基本一致，只有在path数组的构造有些差别
  2. 通过两次对path数组的升级，让最短路径的生成与存储形式更加直接，更好理解，可视化更强，但避免不了的是3.0版本是最复杂的。

完整源代码：

  • 1.0版本：
#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");
	   }
	 printf("\n-----------------------------------------------");
}

int dist[VertexMax][VertexMax];
int path[VertexMax][VertexMax];

void ShortestPath_Floyd(MGraph G)
{
	int i,j,k;

	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			dist[i][j]=G.AdjMatrix[i][j];
			
			if(dist[i][j]!=MaxInt)
		            {
		              	path[i][j]=i;//存入前驱 
					}
			else path[i][j]=-1;
		}
	}

	for(k=0;k<G.vexnum;k++)//拿出每个顶点作为遍历条件
	 for(i=0;i<G.vexnum;i++)
	  for(j=0;j<G.vexnum;j++)
	   {
	   	    if(dist[i][j]>dist[i][k]+dist[k][j])
	   	    {
	   	    	dist[i][j]=dist[i][k]+dist[k][j];
	   	    	path[i][j]=path[k][j];//存入前驱 
			} 
       }

}	  

void DisplayPath(MGraph G)
{
	int i,j,k;
	
	//1.打印path数组 
	printf("\nPath:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
	  {
	 	printf("\t%d",path[i][j]);
	  }
	  printf("\n");
	}
	
	//2.打印dist数组  
	printf("\nDist:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
	  {
	  	if(dist[i][j]!=MaxInt)
		  {
		  	printf("\t%d",dist[i][j]);
		  }
		else printf("\t∞");   
	  }
	  printf("\n");
	}
	
	//3.展示最短路径及路径长度（权值）
	printf("\n最短路径(逆序)：\n\n"); 
	for(i=0;i<G.vexnum;i++)
	{
	 	for(j=0;j<G.vexnum;j++)
	 	{
	 		printf("%c-%c:",G.Vertex[i],G.Vertex[j]);
	 		
	 		if(dist[i][j]==MaxInt)
	 		  printf("%c不可达%c\n",G.Vertex[i],G.Vertex[j]);
	 		else
			{
				printf("%c",G.Vertex[j]);//终点 
				
				k=path[i][j];
				printf("%c",G.Vertex[k]);//倒数第二个点 
				
				while(path[i][k]!=-1)
				{
					k=path[i][k];
					printf("%c",G.Vertex[k]);//后续点 
				}
				printf("\t(%d)",dist[i][j]);
				printf("\n");
			} 
		}
	} 
	 	 
} 

int main() 
{
	MGraph G;
	VertexType start;
 
	CreateDN(&G);
	print(G);
	ShortestPath_Floyd(G);
	DisplayPath(G);
	
	return 0;
}
  • 2.0版本：
#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");
	   }
	 printf("\n-----------------------------------------------");
}

int dist[VertexMax][VertexMax];
int path[VertexMax][VertexMax];

void ShortestPath_Floyd(MGraph G)
{
	int i,j,k;

	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			dist[i][j]=G.AdjMatrix[i][j];
			
			if(dist[i][j]!=MaxInt)
		            {
		              	path[i][j]=j;//存入后继 
					}
			else path[i][j]=-1;
		}
	}

	for(k=0;k<G.vexnum;k++)//拿出每个顶点作为遍历条件
	 for(i=0;i<G.vexnum;i++)
	  for(j=0;j<G.vexnum;j++)
	   {
	   	    if(dist[i][j]>dist[i][k]+dist[k][j])
	   	    {
	   	    	dist[i][j]=dist[i][k]+dist[k][j];
	   	    	path[i][j]=path[i][k];//存入后继 
			} 
       }

}	  

void DisplayPath(MGraph G)
{
	int i,j,k;
	
	//1.打印path数组 
	printf("\nPath:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
	  {
	 	printf("\t%d",path[i][j]);
	  }
	  printf("\n");
	}
	
	//2.打印dist数组  
	printf("\nDist:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
	  {
	  	if(dist[i][j]!=MaxInt)
		  {
		  	printf("\t%d",dist[i][j]);
		  }
		else printf("\t∞");   
	  }
	  printf("\n");
	}
	
	//3.展示最短路径及路径长度（权值）
	printf("\n最短路径：\n\n"); 
	for(i=0;i<G.vexnum;i++)
	{
	 	for(j=0;j<G.vexnum;j++)
	 	{
	 		printf("%c-%c:",G.Vertex[i],G.Vertex[j]);
	 		
	 		if(dist[i][j]==MaxInt)
	 		  printf("%c不可达%c\n",G.Vertex[i],G.Vertex[j]);
	 		else
			{
				printf("%c",G.Vertex[i]);//起点 
				
				k=path[i][j];
				printf("%c",G.Vertex[k]);//第二个点 
				
				while(path[k][j]!=-1)
				{
					k=path[k][j];
					printf("%c",G.Vertex[k]);//后续点 
				}
				printf("\t(%d)",dist[i][j]);
				printf("\n");
			} 
		}
	} 
	 	 
} 

int main() 
{
	MGraph G;
	VertexType start;
 
	CreateDN(&G);
	print(G);
	ShortestPath_Floyd(G);
	DisplayPath(G);
	
	return 0;
}
  • 3.0版本：
#include <stdio.h>
#include <stdlib.h>
#include <string.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");
	   }
	printf("\n-----------------------------------------------\n"); 
}

int dist[VertexMax][VertexMax];
VertexType path[VertexMax][VertexMax][VertexMax];  

char *NewPath(char temp1[VertexMax],char temp2[VertexMax])
{
	int i=0;
	static char ch1[VertexMax],ch2[VertexMax];
	
	for(i=0;i<VertexMax;i++)
	{
		ch1[i]=temp1[i];
		ch2[i]=temp2[i]; 
	}
	i=0;
	
    while(ch1[i]!='\0')
    {
    	i++;
	}
	
	if(ch1[i-1]!=ch2[0])
	{
		strcpy(&ch1[i],&ch2[0]);
	}
	else if(ch1[i-1]==ch2[0])
	{
		strcpy(&ch1[i-1],&ch2[0]);
	}
	
   return ch1;
}

void ShortestPath_Floyd(MGraph G)
{
	int i,j,k;
	char temp1[2]="0",temp2[2]="0";
	
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			dist[i][j]=G.AdjMatrix[i][j];
			
			if(dist[i][j]!=MaxInt)
		            {
		              	temp1[0]=G.Vertex[i];
		              	temp2[0]=G.Vertex[j];
		              	strcpy(path[i][j],NewPath(temp1,temp2));
					}
			else strcpy(path[i][j],"0");
		}
	}
	
	for(k=0;k<G.vexnum;k++)//拿出每个顶点作为遍历条件
	 for(i=0;i<G.vexnum;i++)
	  for(j=0;j<G.vexnum;j++)
	   {
	   	    if(dist[i][j]>dist[i][k]+dist[k][j])
	   	    {
	   	    	dist[i][j]=dist[i][k]+dist[k][j];
	   	    	strcpy(path[i][j],NewPath(path[i][k],path[k][j]));
			} 
       }
}	  


void DisplayPath(MGraph G)
{
	
	int i,j,k;
	
	printf("Dist:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			if(dist[i][j]==MaxInt)
			{
				printf("\t∞");
			}
			else printf("\t%d",dist[i][j]);
		}
		printf("\n");
	}
	
	printf("Path:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
		{
			printf("\t%s",path[i][j]); 
		}
		printf("\n");
	}
	printf("\n"); 
	
	for(i=0;i<G.vexnum;i++)//打印最短路径 
	{
		for(j=0;j<G.vexnum;j++)
		{
			printf("%c到%c的最短路径:",G.Vertex[i],G.Vertex[j]);
			if(path[i][j][0]=='0')
			{
				printf("不可达\n\n"); 
			}
			else
			{
				printf("%s",path[i][j]);
				printf(" (%d)\n\n",dist[i][j]);
			} 
			
		}
	}
}

int main() 
{
	MGraph G;
	VertexType start;

	CreateDN(&G);
	print(G);
	ShortestPath_Floyd(G);
    DisplayPath(G);
	return 0;
}

执行结果：

  • 1.0版本：
  • 2.0版本：
  • 3.0版本：

参考：

  1. Floyd算法思想部分参考：数据结构——解学武
  2. 部分算法思路来自于：西电的小姐姐KittyGirllll
  3. 部分算法思路来自于：懒猫老师
Attract1206
关注
  • 36
    点赞
  • 踩
  • 113
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
求有向网中任意一对顶点之间的最短路径 Floyd算法
hmh86的博客
12-15 1989
有向网中欲知任意一对顶点之间的最短路径常用Floyd算法，基本思想是任意一对顶点vi与vj，逐步在其中加入一个中间节点v0,..,vk,...vn，若比原路径短则更新最短路径，经过n次比较和修正后，vi到vj的最短路径可以求出。具体代码及相关注释如下 //floyd求任意顶点间的最短路径 #include #define N 20//最大顶点数 #define INF 10000 typedef
7-1 最短路径之Floyd(重在原理而不在题目)
Lee贤的博客
11-09 996
首先可以用邻接矩阵储存有向图，（若为非连通图再加判断条件即可），用一个二维数组如d[i][j]表示i到j的最短路径的长度距离，初始时先将邻接矩阵中能直接相邻的两个节点的距离权值赋值给d，接下来就要找出不是直接到达但是距离反而比直接到达的距离减少了的情况，对于每两个点来说，中间可能经过从1到n-2个点不等，算法实现是一个三重for循环，其中k为经过的中转点，i为起点，j为终点，通过比较d[i][j]和d[i][k]+d[k][j]的大小来更新d[i][j]的最小值，
C语言数据结构与算法---最短路径（迪杰斯特拉算法）
myjess’s blog
03-02 5986
文章目录一. 最短路径二. 迪杰斯特拉(Dijkstra)算法1. 算法思路2. 代码实现 一. 最短路径 在网图和非网图中，最短路径的含义是不同的 非网图：因为边上没有权值，所谓最短路径，其实是指两个顶点之间经过的边数最少的路径。 网图：两点之间经过的边上权值之和最少的路径。称路径上第一个顶点是源点，最后一个顶点是终点。 二. 迪杰斯特拉(Dijkstra)算法 用于单源最短路径 1. 算法思路...
最短路径算法—Floyd(弗洛伊德)算法分析与实现(C/C++)
WUYUAN2011WOAINI的专栏
10-24 6740
原文地址：http://www.wutianqi.com/?p=1903 Floyd-Warshall算法，简称Floyd算法，用于求解任意两点间的最短距离，时间复杂度为O(n^3)。 使用条件&范围 通常可以在任何图中使用，包括有向图、带负权边的图。 Floyd-Warshall 算法用来找出每对点之间的最短距离。它需要用邻接矩阵来储存边，这个算法通过考虑最佳子路径来得到最佳路径。 1
最短路径(C语言实现)
qq_42453280的博客
05-07 1万+
Dijkstra算法具体步骤： （1）初始时，S集合只包含源点(S={v})，U集合包含剩余的点，源点v到自己的距离为0，到其他顶点的距离均为无穷大(表示不可达)，以此更新dist[]数组，除dist[v]=0之外，其余全为无穷大； （2）在dist[]数组中，找到目前在U集合中且使得源点v到其距离最小的顶点k，将该顶点加入U集合，并作为新的源点； （3）根据新源点k，更新该源点到其他顶点的最小距...
C语言实现图的最短路径Floyd算法
12-31
Floyd算法直接使用二维数组求出所有顶点到所有顶点的最短路径。 D代表顶点到顶点的最短路径权值和的矩阵。 P代表对应顶点的最小路径的前驱矩阵。 以下程序在DEV C++中调试运行通过。 #include <stdio> #define ...
算法-最短路径-Floyd算法
05-21
算法-最短路径-Floyd算法
C例子：最短路径（floyd算法）
10-11
该程序是我写的博客“一起talk C栗子吧（第五十五回：C语言实例--图的最短路径三）”的配套程序，共享给大家使用
floyd最短路径算法
11-01
Floyd算法是经典的最短路径算法之一,应用广泛，可以求解多对多和一对一的最短路；
最短路径的C代码
07-31
最短路径的实现 shorttest_path.cpp 为源代码文件 cityname.txt 保存城市名及数量 citipath.txt 保存两两城市之间的距离 minpath.txt 城市间最短路径（注意因程序保存的是二进制文件所以用记事本打开是乱码） short_path.exe 可执行文件主要有三个功能：1--计算城市间最短路径及各城市流量大小（这里我们假设了每个城市到其他城市的出行是等可能的）；2---求一个城市到其它城市的最短路径；3---求一个城市到另一个城市的最短路径）
C语言（floyd算法 最短路径）
04-29
C语言（floyd算法 最短路径），但没有注释 请谅解。。。。希望对大家有帮助。
Dijkstra及其复杂度证明
q779的博客
03-28 1万+
没有摘要 qwq
单源最短路径Dijkstra算法
魔神翼
02-09 1297
算法简介　　Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。Dijkstra一般的表述通常有两种方式，一种用永久和临时标号方式，一种是用OPEN, CLOSE表的
最短路径(Floyd)
DL猿
11-06 730
给定带权有向图 G=（V, E）, 对任意顶点vi,vj 属于V,(i!=j) 求顶点vi到顶点vj的最短路径 解决办法: 弗洛伊德提出的求每一对顶点之间的最短路径算法-----Floyd算法 基本思想:对于
C语言-图的存储结构（邻接矩阵）
Attract's Blog
05-29 1万+
查找函数（LocateVex查找坐标） 构建有向图（Directed Graph） 构建无向图（Undirected Graph） 构建有向网（Directed Network） 构建无向网（Undirected Network） 图的类型选择函数（GraphChoice） 输出邻接矩阵（print） 完整源代码： #include <stdio.h> #include <stdlib.h> #include <string.h> #define VertexMax .
floyd算法模板--打印路径
yuanba_xs的博客
01-31 1961
#include #include #include #include #define N 1005 #define INF 0x3f3f3f3f using namespace std; int m, n; int map[N][N]; void init() { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n;
图的应用-C语言实现Floyd（弗洛伊德算法）算法
程序员象漂亮的博客
07-04 1724
图的应用 请根据学校地图，任意选择一个起点和一个终点，并根据上图所示，选择起点到终点的最短路径。 要求如下: 1) 构造一个图，并规划起点到终点的路线，简述构建这条路线的思路。 2) 用算法实现你的分析思路，并输出路径。 (包括代码和运行结果的截图)3) 分析算法的性能，至少包括时间复杂度和空间复杂度等
C++实现图 - 04 最短路径
Newin2020的博客
06-20 2143
数据结构与算法专栏 —— C++实现迪杰斯特拉算法是一个单源点的一个最短路径算法，也就是说，我们这个算法会求得从一个顶点到其所有顶点的最短路径。这个算法需要用到邻接矩阵来存储所有边值，并且需要一个辅助数组来更新最短路径，需要一个路径数组存储最短路径的结点，还需要一个状态数组来判断当前结点是否已经加入最短路径。这样说可能会有点晕，我们还是先来看图，假设有这样一张图：现在，我们要找到结点 0 到结点 8 的最短路径，步骤如下：第一步：初始化我们上述提到的三个数组，将结点 0 加入数组中，并更新辅助数组即结点 0
最短路径问题---Floyd算法详解
热门推荐
William
03-11 29万+
前言 Genius only means hard-working all one’s life. Name:Willam Time:2017/3/81、最短路径问题介绍问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径解决问题的算法： 迪杰斯特拉算法（Dijkstra算法） 弗洛伊德算法（Floyd算法） SPFA算法 之前已经对Di
c语言算法导航最短路径查询
最新发布
01-06
C语言是一种通用的程序设计语言，可以用于编写各种算法。在导航系统中，最短路径查询是一个十分常见的问题。通过使用C语言编写算法，我们可以实现最短路径查询功能。 最短路径查询算法的核心思想是使用图论中的相关算法，比如Dijkstra算法或者Floyd-Warshall算法。这些算法可以帮助我们找到两点之间的最短路径，无论是在地图上的路线规划还是在网络中的数据传输。 使用C语言编写最短路径查询算法时，我们需要先定义一个合适的数据结构来表示图，比如使用邻接矩阵或者邻接表。然后我们可以根据具体的问题选择合适的算法进行实现。 通过编写C语言算法实现最短路径查询，我们可以获得高效的性能和灵活的扩展性。C语言作为一种底层语言，可以直接操作内存，并且有着良好的性能表现。同时，C语言的代码结构清晰，易于理解和维护，可以满足复杂导航系统中的需求。 总之，通过使用C语言编写算法来实现最短路径查询，我们可以得到高效、可靠并且易于维护的导航系统，为用户提供更好的出行体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Attract1206

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值