C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储

已于 2024-09-13 22:07:58 修改
阅读量774 收藏 6
点赞数 5
文章标签： c语言 数据结构 算法
于 2024-09-13 00:18:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BamBoo_Bean/article/details/142188563
版权

        弗洛伊德算法相比迪杰斯特拉相似的地方都是遍历邻接矩阵不断调整最短路径的信息，并且两种算法面对多源最短路径的时间复杂度都是O(n^3)，Floyd采用的是动态规划而Dijkstra是采用贪心的思想。在Floyd中我们将创建两个数组进行辅助，一个path二维数组用于存储路径信息，一个table二维数组用于记录更新各结点间的最短路径长度，table的初始化就是简单的把邻接矩阵的信息复制过来，整个算法都是在这个table表中不断更新，代码中第一层for循环是控制中转结点，另外两行就是遍历整个table二位数组，table[v][k]表示辅助列，table[k][w]表示辅助行，辅助行与辅助列由中转结点控制在整个table表的主对角线上运动，table[v][w]当前扫描的邻接结点信息，如果当前邻接结点的权值大于对应的（辅助行+辅助列的权值和），那么说明找到更短的路径需要进行更新权值，当前邻接结点信息改为（辅助行+辅助列的权值和），同时更新路径信息为中转结点（即前驱顶点），代码中path[v][k]存储了对应的中转结点信息，利用它更新当前邻接结点的前驱结点（对应的中转结点）信息，当循环结束整个图各顶点到达其他所有顶点的最短距离就计算完成了，最后我们打印table矩阵的上三角部分因为两个结点的表示可以用一个方向就行，例如A->F打印了就可以表示F->A，并不需求遍历完全部table矩阵信息，同时打印路径信息的第二个for循环有个+1操作是为了避免打印AA、BB这种自己到自己的路径，也就是不打印主对角线，path路径信息的存储也同样用到并查集的部分思想在上一篇博文提过，在代码中通过不断循环path路径能够找到它的前驱结点一步步把所有路径结点信息找到，相比迪杰斯特拉倒着找结点信息，这里我们可以之间通过path二维数组顺序查找到路径信息，也是非常巧妙的！

 我们将创建下面的无向权值图：

84ef03cba4ba478383b338ae5884012a.png

  邻接矩阵的绘制还是手动赋值上三角，并通过矩阵对称性生成整个邻接矩阵，其中最小生成树中需要用到权值，对应原本有边的地方之前我是用1表示，现在改成边对应的权值，之前的0表示没有边，现在改成99表示为无穷，其实应该换成更大的值以确保树的边权值都小于这个最大值，但为了方便对齐显示看邻接矩阵，就使用了比本图中各边长较大的99来表示最大值。

9eefaa5c866742cbb239f5f9de2aff7d.png

Floyd算法代码：

//存储所有顶点的路径信息
typedef int Patharc[MAXVEX][MAXVEX];
//最短路径表copy邻接矩阵，不断扫描更新各顶点相互间的最短距离
typedef int ShortestPathTable[MAXVEX][MAXVEX];
// Floyd算法实现
void Floyd(MGraph G, Patharc path, ShortestPathTable table) {
	int v, w, k;
	// 初始化表和路径矩阵
	for (v = 0; v < G.numNodes; v++) {
		for (w = 0; w < G.numNodes; w++) {
			table[v][w] = G.arc[v][w];  // 初始化最短路径表
			if (G.arc[v][w] < INFINITY) {
				path[v][w] = w;  // 有直接边时，路径是目标顶点
			}
			else {
				path[v][w] = -1; // 如果没有边，则设为 -1
			}
		}
	}

	// Floyd算法的核心计算
	for (k = 0; k < G.numNodes; k++) {  // 遍历每个顶点作为中间顶点
		for (v = 0; v < G.numNodes; v++) {  // 遍历起点
			for (w = 0; w < G.numNodes; w++) {  // 遍历终点
				// 如果通过顶点 k 的路径更短，则更新路径和最短路径表
				if (table[v][w] > table[v][k] + table[k][w]) {
					table[v][w] = table[v][k] + table[k][w];
					path[v][w] = path[v][k];
				}
			}
		}
	}

	// 打印各顶点间的最短路径
	printf("各顶点间最短路径如下：\n");
	for (v = 0; v < G.numNodes; v++) {
		for (w = v + 1; w < G.numNodes; w++) {  // 遍历每对顶点
			//Array数组存储顶点ABCDEFGH
			printf("%c-%c weight:%d\n", Array[v], Array[w], table[v][w]);
			k = path[v][w];  // 从起点到终点的路径
			printf("path:%d", v);
			while (k != w) {  // 路径输出
				printf("->%d", k);
				k = path[k][w];
			}
			printf("->%d\n", w);
		}
		printf("\n");
	}
}

完整代码（包括邻接矩阵的创建、Floyd算法）

#include "stdio.h"    
#include "stdlib.h"   
#include "math.h"  
#include "time.h"

// 禁用特定的警告
#pragma warning(disable:4996)

// 定义一些常量和数据类型
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXVEX 8 /* 最大顶点数，用户定义 */
#define MAXEDGE 10 /* 最大边数，用户定义 */
#define GRAPH_INFINITY 99 /* 用0表示∞，表示不存在边 */

/* 定义状态、顶点和边的类型 */
typedef int Status;  /* Status是函数的返回类型，如OK表示成功 */
typedef char VertexType; /* 顶点的类型，用字符表示 */
typedef int EdgeType; /* 边上的权值类型，用整数表示 */
typedef int Boolean; /* 布尔类型 */
// 定义顶点标签
char Array[] = "ABCDEFGHI";

/* 图的邻接矩阵结构体 */
typedef struct
{
	VertexType vexs[MAXVEX]; /* 顶点表 */
	EdgeType arc[MAXVEX][MAXVEX]; /* 邻接矩阵，表示边的权值 */
	int numNodes, numEdges; /* 图中当前的顶点数和边数 */
} MGraph;

//存储所有顶点的路径信息
typedef int Patharc[MAXVEX][MAXVEX];
//最短路径表copy邻接矩阵，不断扫描更新各顶点相互间的最短距离
typedef int ShortestPathTable[MAXVEX][MAXVEX];

/* 创建一个无向网图的邻接矩阵表示 */
void CreateMGraph(MGraph* G)
{
	int i, j, k, w;
	// 初始化图的顶点数和边数
	G->numNodes = 8;
	G->numEdges = 10;
	// 初始化邻接矩阵和顶点表
	for (i = 0; i < G->numNodes; i++) {
		for (j = 0; j < G->numNodes; j++) {
			G->arc[i][j] = GRAPH_INFINITY; /* 初始化邻接矩阵为∞ */
		}
		G->vexs[i] = Array[i]; /* 初始化顶点表 */
	}
	G->arc[0][0] = GRAPH_INFINITY;
	G->arc[0][1] = 10;
	G->arc[0][2] = GRAPH_INFINITY;
	G->arc[0][3] = GRAPH_INFINITY;
	G->arc[0][4] = GRAPH_INFINITY;
	G->arc[0][5] = 11;
	G->arc[0][6] = GRAPH_INFINITY;
	G->arc[0][7] = GRAPH_INFINITY;

	G->arc[1][0] = GRAPH_INFINITY;
	G->arc[1][1] = GRAPH_INFINITY;
	G->arc[1][2] = 23;
	G->arc[1][3] = GRAPH_INFINITY;
	G->arc[1][4] = GRAPH_INFINITY;
	G->arc[1][5] = GRAPH_INFINITY;
	G->arc[1][6] = 12;
	G->arc[1][7] = GRAPH_INFINITY;

	G->arc[2][0] = GRAPH_INFINITY;
	G->arc[2][1] = GRAPH_INFINITY;
	G->arc[2][2] = GRAPH_INFINITY;
	G->arc[2][3] = 21;
	G->arc[2][4] = GRAPH_INFINITY;
	G->arc[2][5] = GRAPH_INFINITY;
	G->arc[2][6] = GRAPH_INFINITY;
	G->arc[2][7] = GRAPH_INFINITY;

	G->arc[3][0] = GRAPH_INFINITY;
	G->arc[3][1] = GRAPH_INFINITY;
	G->arc[3][2] = GRAPH_INFINITY;
	G->arc[3][3] = GRAPH_INFINITY;
	G->arc[3][4] = GRAPH_INFINITY;
	G->arc[3][5] = GRAPH_INFINITY;
	G->arc[3][6] = GRAPH_INFINITY;
	G->arc[3][7] = 11;

	G->arc[4][0] = GRAPH_INFINITY;
	G->arc[4][1] = GRAPH_INFINITY;
	G->arc[4][2] = GRAPH_INFINITY;
	G->arc[4][3] = GRAPH_INFINITY;
	G->arc[4][4] = GRAPH_INFINITY;
	G->arc[4][5] = 47;
	G->arc[4][6] = GRAPH_INFINITY;
	G->arc[4][7] = 80;

	G->arc[5][0] = GRAPH_INFINITY;
	G->arc[5][1] = GRAPH_INFINITY;
	G->arc[5][2] = GRAPH_INFINITY;
	G->arc[5][3] = GRAPH_INFINITY;
	G->arc[5][4] = GRAPH_INFINITY;
	G->arc[5][5] = GRAPH_INFINITY;
	G->arc[5][6] = 6;
	G->arc[5][7] = GRAPH_INFINITY;

	G->arc[6][0] = GRAPH_INFINITY;
	G->arc[6][1] = GRAPH_INFINITY;
	G->arc[6][2] = GRAPH_INFINITY;
	G->arc[6][3] = GRAPH_INFINITY;
	G->arc[6][4] = GRAPH_INFINITY;
	G->arc[6][5] = GRAPH_INFINITY;
	G->arc[6][6] = GRAPH_INFINITY;
	G->arc[6][7] = 8;

	G->arc[7][0] = GRAPH_INFINITY;
	G->arc[7][1] = GRAPH_INFINITY;
	G->arc[7][2] = GRAPH_INFINITY;
	G->arc[7][3] = GRAPH_INFINITY;
	G->arc[7][4] = GRAPH_INFINITY;
	G->arc[7][5] = GRAPH_INFINITY;
	G->arc[7][6] = GRAPH_INFINITY;
	G->arc[7][7] = GRAPH_INFINITY;

	// 由于是无向图，邻接矩阵是对称的，需要将其对称
	for (int i = 0; i < G->numNodes; i++) {
		for (int j = 0; j < G->numNodes; j++) {
			G->arc[j][i] = G->arc[i][j];
		}
	}
	// 打印邻接矩阵
	printf("邻接矩阵为：\n");
	printf("     ");
	for (int i = 0; i < G->numNodes; i++) {
		printf("%2d ", i); /* 打印列索引 */
	}
	printf("\n     ");
	for (int i = 0; i < G->numNodes; i++) {
		printf("%2c ", G->vexs[i]); /* 打印顶点标签 */
	}
	printf("\n");
	for (int i = 0; i < G->numNodes; i++) {
		printf("%2d", i); /* 打印行索引 */
		printf("%2c ", G->vexs[i]); /* 打印顶点标签 */
		for (int j = 0; j < G->numNodes; j++) {
			if (G->arc[i][j] != 99) {
				printf("\033[31m%02d \033[0m", G->arc[i][j]); /* 打印邻接矩阵中的权值 */
			}
			else {
				printf("%02d ", G->arc[i][j]); /* 打印邻接矩阵中的权值 */
			}
		}
		printf("\n");
	}
}

// Floyd算法实现
void Floyd(MGraph G, Patharc path, ShortestPathTable table) {
	int v, w, k;
	// 初始化表和路径矩阵
	for (v = 0; v < G.numNodes; v++) {
		for (w = 0; w < G.numNodes; w++) {
			table[v][w] = G.arc[v][w];  // 初始化最短路径表
			if (G.arc[v][w] < INFINITY) {
				path[v][w] = w;  // 有直接边时，路径是目标顶点
			}
			else {
				path[v][w] = -1; // 如果没有边，则设为 -1
			}
		}
	}

	// Floyd算法的核心计算
	for (k = 0; k < G.numNodes; k++) {  // 遍历每个顶点作为中间顶点
		for (v = 0; v < G.numNodes; v++) {  // 遍历起点
			for (w = 0; w < G.numNodes; w++) {  // 遍历终点
				// 如果通过顶点 k 的路径更短，则更新路径和最短路径表
				if (table[v][w] > table[v][k] + table[k][w]) {
					table[v][w] = table[v][k] + table[k][w];
					path[v][w] = path[v][k];
				}
			}
		}
	}

	// 打印各顶点间的最短路径
	printf("\n各顶点间最短路径如下：\n");
	for (v = 0; v < G.numNodes; v++) {
		for (w = v + 1; w < G.numNodes; w++) {  // 遍历每对顶点
			//Array数组存储顶点ABCDEFGH
			printf("%c-%c weight:%d\n", Array[v], Array[w], table[v][w]);
			k = path[v][w];  // 从起点到终点的路径
			printf("path:%d", v);
			while (k != w) {  // 路径输出
				printf("->%d", k);
				k = path[k][w];
			}
			printf("->%d\n", w);
		}
		printf("\n");
	}
}

// 主函数
int main(void) {
	MGraph G;
	/* 创建图 */
	CreateMGraph(&G);  // 创建并初始化图 G
	Patharc path;
	ShortestPathTable table;
	Floyd(G, path, table);  // 计算最短路径
	return 0;
}

 无向权值图：

84ef03cba4ba478383b338ae5884012a.png

运行结果：

Happy鱿鱼
关注
C例子：最短路径（floyd算法）
10-11
该程序是我写的博客“一起talk C栗子吧（第五十五回：C语言实例--图的最短路径三）”的配套程序，共享给大家使用
C语言实现Floyd算法
08-28
主要为大家详细介绍了C语言实现Floyd算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
有向图邻接矩阵c语言编程,邻接矩阵有向图(一)之 C语言详解
weixin_31569671的博客
05-18 4459
本章介绍邻接矩阵有向图。在"图的理论基础"中已经对图进行了理论介绍，这里就不再对图的概念进行重复说明了。和以往一样，本文会先给出C语言的实现；后续再分别给出C++和Java版本的实现。实现的语言虽不同，但是原理如出一辙，选择其中之一进行了解即可。若文章有错误或不足的地方，请不吝指出！邻接矩阵有向图的介绍邻接矩阵有向图是指通过邻接矩阵表示的有向图。上面的图G2包含了"A,B,C,D,E,F,G"共7...
最短路径---Floyd算法（C++）
Nick
12-05 5740
Floyd算法的介绍 算法的特点：  弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或有向图或负权（但不可存在负权回路)的最短路径问题，同时也被用于计算有向图的传递闭包。 算法的思路 通过Floyd计算图G=(V,E)中各个顶点的最短路径时，需要引入两个矩阵，矩阵S中的元素a[i][j]表示顶点i(第i个顶点)到顶点j(第j个顶点)的距离。矩阵P中的元素b[i][j]，表...
c++图论算法1——Floyd（弗洛伊德）算法
Ocean103的博客
12-04 3533
简单介绍弗洛伊德算法的工作原理，代码实现等
Floyd算法图解，C++实现Floyd算法
weixin_40355471的博客
06-17 1458
C++实现Floyd算法：Floyd算法是一种多源最短路径算法,是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。时间复杂度：O（n^3），空间复杂度：O（n^2）。初始化权重矩阵weitMatrix[][]和路径矩阵pathMatrix[][]，遍历所有点。
【数据结构】图—弗洛伊德（Floyd）算法
qq_41563510的博客
05-13 5046
前言 上文介绍了迪杰斯特拉(Dijkstra)算法，计算网图的某个源点到其余各个顶点的最短路径问题（边权值为非负值），本文介绍另一个求最短路径的算法——弗洛伊德算法，它是计算所有顶点到所有顶点的最短路径，其时间复杂度为O(n3)O(n^3)O(n3)，其算法相比Dijkstra算法更加简洁易懂。 算法思路 在迪杰斯特拉算法中，定义了两个一维数组int D[MAXVEX]和 int P[MAXVEX]，D表示源点到其他顶点的最短路径和，P表示对应顶点的最小路径的前驱矩阵。 因为弗洛伊德算法中，以所有顶..
C++数据结构与算法分析——Floyd算法
l_red_forest的博客
10-15 3057
介绍 Floyd算法是一种求多源汇最短路的算法，它可以求出任意两点间的最短距离(如果这两点连通的话)，并且Floyd算法非常容易实现： 算法模板O(n3)O(n^3)O(n3) for(int k = 1; k <= n; k ++) for(int i = 1; i <= n; i ++) for(int j = 1; j <= n; j ++) d[i][j] = min(d[i][j],d[i][k] + d[k][j]); 它总共有3层循环，每层n次，所以时间复杂度为
交通咨询系统数据结构c语言.doc
03-27
邻接矩阵是一种常用的数据结构，用于表示图中各节点之间的连接关系。在这个系统中，我们用二维数组来存储邻接矩阵，其中的元素表示两个城市之间的距离或权值。这种结构便于判断任意两个城市之间是否存在直接连接以及...
c语言数据结构算法演示(Windows版)
11-03
弗洛伊德算法(shortpath_Floyd)  迪杰斯特拉算法(shortpath_DIJ) 9． 存储管理 （1）边界标识法 (Boundary_tag_method) （2）伙伴系统 (Buddy_system) （3）紧缩无用单元 (Storage_compaction) 10． 静态...
Floyd算法c语言实现
07-26
Floyd算法，最短路径算法，c语言实现。
数据结构之Floyd算法
04-17
**Floyd算法，也称为Floyd-...总的来说，理解并掌握Floyd算法对于学习数据结构和算法，尤其是图论部分，是非常重要的。通过阅读和分析`Floyed.c`，你可以深入了解该算法的实现细节，并通过实践加深对算法的理解。
弗洛伊德算法c语言实现
11-20
根据提供的文件信息，我们可以深入探讨弗洛伊德算法在C语言中的实现及其应用场景。 ### 弗洛伊德算法概述 弗洛伊德算法是一种解决**任意两点之间最短路径问题**的经典算法，适用于带权有向图。它通过动态规划的...
数据结构：弗洛伊德算法（最短路径）图文详解
热门推荐
weixin_52797843的博客
11-30 2万+
弗洛伊德算法通过邻接矩阵存储图（有向图或者无向图）的信息，两点的距离，通过动态转移方程 a[i][j] = min(a[i][j], a[i][p] + a[p][j]); 来更新最短路径，求出各个点之间的最短路径
图的应用-C语言实现Floyd（弗洛伊德算法）算法
程序员象漂亮的博客
07-04 1794
图的应用 请根据学校地图，任意选择一个起点和一个终点，并根据上图所示，选择起点到终点的最短路径。 要求如下: 1) 构造一个图，并规划起点到终点的路线，简述构建这条路线的思路。 2) 用算法实现你的分析思路，并输出路径。 (包括代码和运行结果的截图)3) 分析算法的性能，至少包括时间复杂度和空间复杂度等
Floyd （弗洛伊德）算法简述
慕羽★的博客
10-15 2万+
Floyd在1962年由Robert Floyd以其当前公认的形式出版。算法作为三个嵌套for循环的现代公式首先由Peter Ingerman在1962年描述。Floyd 算法是解决图论问题的比较经典的算法，是解决给定的加权图中顶点间的最短路径的一种算法，可以正确处理有向图的最短路径问题。
数据结构和算法:程序员常用的10种算法之弗洛伊德算法
weixin_43597208的博客
08-08 244
1）和Dijkstra算法一样，弗洛伊德（Floyd）算法也是一种用于寻找给定的加权图中顶点间最短路径的算法，该算法名称以创始人之一、1978年图灵奖得主、斯坦福大学计算机科学系教授罗伯特。弗洛伊德命名2）弗洛伊德算法（Floyd）计算图中各个顶点之间的最短路径3）迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径。
【数据结构】最短路径算法实现（Dijkstra（迪克斯特拉），FloydWarshall（弗洛伊德） ）
最新发布
m0_74774759的博客
12-23 3016
最短路径问题：从在带权有向图G中的某一顶点出发，找出一条通往另一顶点的最短路径，最短也就是沿路径各边的权值总和达到最小。单源最短路径问题：给定一个图G = ( V ， E ) G=(V，E)G=(V，E)，求源结点s ∈ V s∈Vs∈V到图中每个结点v ∈ V v∈Vv∈V的最短路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值