最短路径(Floyd算法)

最新推荐文章于 2025-09-07 17:54:15 发布

原创最新推荐文章于 2025-09-07 17:54:15 发布 · 2.2k 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#算法 #graph #struct #path #测试

数据结构专栏收录该内容

38 篇文章

订阅专栏

本文介绍了Floyd算法，一种用于解决加权图中最短路径问题的算法。通过Floyd算法，可以找到图中任意两个顶点之间的最短路径。算法包括头文件Floyd.h、实现文件Floyd.cpp以及用于测试的main.cpp文件。

Floyd算法又称为弗洛伊德算法，插点法，是一种用于寻找给定的加权图中顶点间最短路径的算法。

头文件:Floyd.h

#ifndef FLOYD_H
#define FLOYD_H
#define INFINITY 65535
#define MAXVEX 20
#define MAXVEX 20
typedef int ShortPathTable[MAXVEX][MAXVEX];
typedef int ShortPosition[MAXVEX][MAXVEX];
typedef struct graph{
	int Vertex[MAXVEX]; //顶点信息
	int Edge[MAXVEX][MAXVEX]; //边表信息
	int NumVertex,NumEdge; //图的顶点数,边数
}Graph;
void CreateGraph(Graph *G); //建立图
void ShortestPath_Floyd(Graph *G,ShortPosition *p,ShortPathTable *d); //费洛伊德算法
#endif //FLOYD_H

实现文件:Floyd.cpp

#include "Floyd.h"
#include <stdio.h>
void CreateGraph(Graph *G)
{
	G->NumVertex = 9; //图的顶点数为9
	G->NumEdge = 16;  //图的边为16

	for(int i = 0;i < G->NumVertex;++i) //初始化顶点信息
		G->Vertex[i] = i;

	for(int i = 0;i < G->NumVertex;++i)		//初始化边表信息
		for(int j = 0;j < G->NumVertex;++j)
		{
			if(i == j)
				G->Edge[i][j] = 0;
			else
				G->Edge[i][j] = INFINITY;
		}
	//设置图的边表信息
	G->Edge[0][1] = 1;
	G->Edge[0][2] = 5;

	G->Edge[1][2] = 3;
	G->Edge[1][3] = 7;
	G->Edge[1][4] = 5;

	G->Edge[2][4] = 1;
	G->Edge[2][5] = 7;

	G->Edge[3][4] = 2;
	G->Edge[3][6] = 3;

	G->Edge[4][5] = 3;
	G->Edge[4][6] = 6;
	G->Edge[4][7] = 9;

	G->Edge[5][7] = 5;
	G->Edge[6][7] = 2;
	G->Edge[6][8] = 7;
	G->Edge[7][8] = 4;

	for(int i = 0;i < G->NumVertex;++i)  //无向图，存在反向链接
		for(int j = i;j < G->NumVertex;++j)
		{
			G->Edge[j][i] = G->Edge[i][j];
		}
}
void ShortestPath_Floyd(Graph *G,ShortPosition *p,ShortPathTable *d)
{
	for(int i = 0;i < G->NumVertex;++i) //初始化两个矩阵
		for(int j = 0;j < G->NumVertex;++j)
		{
			(*p)[i][j] = j;					//p[i][j]为 j顶点的下标值
			(*d)[i][j] = G->Edge[i][j];		//d[i][j]的值为两顶点间的权值
		}
	for(int k = 0;k < G->NumVertex;++k) //K为中转顶点
	{
		for(int i = 0;i < G->NumVertex;++i)
		{
			for(int j = 0;j < G->NumVertex;++j)
			{
				if((*d)[i][j] > (*d)[i][k] + (*d)[k][j]) //如果两顶点的距离大于经过中转顶点的距离
				{
					(*d)[i][j] = (*d)[i][k] + (*d)[k][j];
					(*p)[i][j] = (*p)[i][k];
				}
			}
		}
	}
}

测试文件:main.cpp

#include "Floyd.h"
#include <stdio.h>
int main()
{
	Graph G;
	int k;
	ShortPathTable d;
	ShortPosition p;
	CreateGraph(&G);
	ShortestPath_Floyd(&G,&p,&d);
	for(int i = 0;i < G.NumVertex;++i)
	{
		for(int j = i + 1;j < G.NumVertex;++j)
		{
			printf("V%d - V%d weight: %d",i,j,d[i][j]);
			k = p[i][j];
			printf(" path: V%d",i);
			while(k != j)
			{
				printf(" -> V%d",k);
				k = p[k][j];
			}
			printf(" -> V%d\n",j);
		}
	}
	printf("\n");
}