大话数据结构之图-邻接矩阵最短路径Floyd(C++)

大话数据结构

Unit6 图

邻接矩阵的最短路径Floyd算法

代码

#include <iostream>
typedef char VertexType;
typedef int EdgeType;
#define MAXVEX 10
#define INFINITY 65535
using namespace std;
int visited[100];
typedef int Pathmatirx[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];

//构建顶点表
typedef struct {
	VertexType vexs[MAXVEX];        //顶点数组
	EdgeType arc[MAXVEX][MAXVEX];   //边的矩阵表示
	int numVertexes, numEdges;      //图中当前的顶点数和边数
}MGraph;


//创建邻接矩阵
void CreatMgraph(MGraph* G) {
	int i, j, k, w;
	cout << "输入顶点数和边数:" << endl;
	cin >> G->numVertexes >> G->numEdges;


	for (i = 0;i < G->numVertexes;i++) {
		cout << "请输入顶点名:" << endl;
		cin >> G->vexs[i];
	}
	//初始化邻接矩阵
	for (i = 0;i < G->numVertexes;i++) {
		for (j = 0;j < G->numVertexes;j++) {
			G->arc[i][j] = INFINITY;
		}
	}
	//构建邻接矩阵
	for (k = 0;k < G->numEdges;k++) {
		cout << "输入边(vi,vj)上的下标i,下标j和权w:" << endl;
		cin >> i >> j >> w;
		G->arc[i][j] = w;
		G->arc[j][i] = G->arc[i][j];
	}
}



void ShortestPath_Floyd(MGraph G, Pathmatirx* P, ShortPathTable* D) {
	int v, w, k;
	for (v = 0;v < G.numVertexes;++v) {
		for (w = 0;w < G.numVertexes;++w) {
			(*D)[v][w] = G.arc[v][w];
			(*P)[v][w] = w;
		}
	}
	for (k = 0;k < G.numVertexes;++k) {
		for (v = 0;v < G.numVertexes;++v) {
			for (w = 0;w < G.numVertexes;++w) {
				if ((*D)[v][w] > (*D)[v][k] + (*D)[k][w]) {
					(*D)[v][w] = (*D)[v][k] + (*D)[k][w];
					(*P)[v][w] = (*P)[v][k];
				}
			}
		}
	}
}

//最短路径的显示代码
void printf_shortPathTable(MGraph G, Pathmatirx* P, ShortPathTable* D) {
	int v, w, k;
	for (v = 0;v < G.numVertexes;++v) {
		for (w = v + 1;w < G.numVertexes;w++) {
			cout << v << w << D[v][w];
			k = *P[v][w];
			cout << v;
			while (k != w) {
				cout << "->" << k;
				k = *P[k][w];
			}
			cout << "->" << w;

		}
		cout << endl;
	}
}


int main() 
{
	MGraph* grap = (MGraph*)malloc(sizeof(MGraph));
	Pathmatirx* P = (Pathmatirx*)malloc(sizeof(Pathmatirx));
	ShortPathTable* D = (ShortPathTable*)malloc(sizeof(ShortPathTable));
	CreatMgraph(grap);
	ShortestPath_Floyd(*grap,P,D);
	//printf_shortPathTable(*grap, P, D);
	free(grap);
	free(P);
	free(D);
	grap = NULL;
	return 0;
}

运行结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
邻接矩阵最短路径的算法通常使用 Dijkstra 算法或 Floyd 算法。 1. Dijkstra 算法 Dijkstra 算法是一种单源最短路径算法,其基本思想是从源节开始,不断扩展最短路径,直到到达目标节为止。具体步骤如下: (1)初始化:将源节 s 到所有节的距离初始化为无穷大,将源节 s 到自身的距离初始化为 0。 (2)遍历:从源节 s 开始,按照距离从小到大的顺序遍历所有节,并更新它们到源节 s 的距离。 (3)更新:对于当前节 u 的所有邻居节 v,如果 u 到源节 s 的距离加上 u 到 v 的距离小于当前已知的 v 到源节 s 的距离,则更新 v 的距离。 (4)重复:重复步骤(2)和(3)直到遍历完所有节或者找到目标节C++ 代码实现: ```c++ const int INF = 0x3f3f3f3f; // 无穷大 int n; // 节数 int G[MAX][MAX]; // 邻接矩阵 int d[MAX]; // s 到各的距离 bool vis[MAX]; // 标记是否已确定最短距离 void Dijkstra(int s) { memset(vis, 0, sizeof(vis)); fill(d, d + n, INF); d[s] = 0; for (int i = 0; i < n; i++) { int u = -1; for (int j = 0; j < n; j++) { if (!vis[j] && (u == -1 || d[j] < d[u])) { u = j; } } vis[u] = true; for (int v = 0; v < n; v++) { if (!vis[v] && G[u][v] != INF && d[u] + G[u][v] < d[v]) { d[v] = d[u] + G[u][v]; } } } } ``` 2. Floyd 算法 Floyd 算法是一种多源最短路径算法,其基本思想是通过中间节的遍历,不断缩小节间的距离,直到得到最终的最短路径。具体步骤如下: (1)初始化:将邻接矩阵 G 初始化为节间的距离。 (2)遍历:从节 i 到节 j 的最短路径可能经过节 k,因此遍历所有可能的 k 值,更新 i 到 j 的最短路径C++ 代码实现: ```c++ const int INF = 0x3f3f3f3f; // 无穷大 int n; // 节数 int G[MAX][MAX]; // 邻接矩阵 void Floyd() { for (int k = 0; k < n; k++) { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { G[i][j] = min(G[i][j], G[i][k] + G[k][j]); } } } } ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

Hang-On

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

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

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

打赏作者

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

抵扣说明:

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

余额充值