C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储

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

        在迪杰斯特拉中，相比普利姆算法，是从顶点出发的一条路径不断的寻找最短路径，在实现的时候需要创建三个辅助数组，记录算法的关键操作，分别是Visited[MAXVEX]记录顶点是否被访问，教材上写的final数组但作用是一样的，然后第二个数组是TmpDistance[MAXVEX]，教材使用的D数组，命名语义化较弱不太好理解，实际用途与TmpDistance一样的，用于记录算法过程中，当前顶点到达邻接顶点的最小值，Path[MAXVEX]用于记录每个顶点的前驱结点，通过它可以记录到达所有顶点路径的路线，非常巧妙！整个算法过程非常像一只长了触角的贪吃蛇，用最短的身长到达所有顶点，触手想象成每次循环中探索最短邻接顶点的操作。

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

84ef03cba4ba478383b338ae5884012a.png

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

9eefaa5c866742cbb239f5f9de2aff7d.png

        Dijkstra算法代码

//v0起点,path路径,d临时辅助最短路径数组
void Dijkstra(MGraph G, int Vstart,int TmpDistance[],int Path[]) {
	int v, w, UpcomingVex, min;
	int Visited[MAXVEX];
	//初始化所有顶点
	for (v = 0; v < G.numNodes; v++) {
		Visited[v] = FALSE;
		TmpDistance[v] = G.arc[Vstart][v];
		Path[v] = -1;
	}
	//起始点路径长度为0
	TmpDistance[Vstart] = 0;
	//起始点标记为已经被访问
	Visited[Vstart] = TRUE;
	//遍历所有顶点,总计遍历n-1次所以，主循环控制次数就从1开始，求得当前顶点Vi到达相邻结点的最近距离的顶点，并标记Visited为已经找到
	for (v = 1; v < G.numNodes; v++) {
		min = GRAPH_INFINITY; // 初始化最小距离为无穷大
		// 寻找当前未访问的顶点中距离起始点最近的顶点
		for (w = 0; w < G.numNodes; w++) {
			if (!Visited[w] && TmpDistance[w] < min) {
				UpcomingVex = w;
				min = TmpDistance[w];
			}
		}
		// 标记找到的顶点为已访问
		Visited[UpcomingVex] = true;
		// 更新从当前顶点到其他顶点的最短路径
		for (w = 0; w < G.numNodes; w++) {
			if (!Visited[w] && (min + G.arc[UpcomingVex][w] < TmpDistance[w])) {
				TmpDistance[w] = min + G.arc[UpcomingVex][w];
				Path[w] = UpcomingVex; // 记录路径
			}
		}
	}
}

打印路径函数，根据Dijkstra算法计算的Path数组进行，Path数组用到了并查集的部分思想，Dijkstra中我们所有顶点都是一个集合，-1表示前驱结点为自身即找到起点，也表示为同一个集合，搜索路径的过程需要一步一步往回查找，用到了并查集中的Find函数，比如A->B->C，我们Path数组是从C顶点出发然后根据path存储的内容找到前驱结点B然后再找到A，我这里为了方便直接用数组存储路径，逆序打印就行，也可以用栈进行存储。

// 打印从起点到各顶点的路径
void PathVexPrint(int Path[]) {
	for (int start = 0; start < MAXVEX; start++) {
		int i = start;
		char tmp[10] = "";
		int count = 0;
		// 追踪路径
		while (i >= 0) {
			tmp[count++] = 'A' + i; // 假设顶点用字母表示
			i = Path[i];
		}
		tmp[count++] = 'A'; // 添加起始点
		// 反向输出路径
		for (int j = count - 1; j >= 0; j--) {
			printf("%c", tmp[j]);
			if (j > 0) {
				printf("->");
			}
		}
		printf("\n");
	}
}

完整代码（包含邻接矩阵的创建、迪杰斯特拉算法）

#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;

/* 创建一个无向网图的邻接矩阵表示 */
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");
	}
}

//v0起点,path路径,d临时辅助最短路径数组
void Dijkstra(MGraph G, int Vstart,int TmpDistance[],int Path[]) {
	int v, w, UpcomingVex, min;
	int Visited[MAXVEX];
	//初始化所有顶点
	for (v = 0; v < G.numNodes; v++) {
		Visited[v] = FALSE;
		TmpDistance[v] = G.arc[Vstart][v];
		Path[v] = -1;
	}
	//起始点路径长度为0
	TmpDistance[Vstart] = 0;
	//起始点标记为已经被访问
	Visited[Vstart] = TRUE;
	//遍历所有顶点,总计遍历n-1次所以，主循环控制次数就从1开始，求得当前顶点Vi到达相邻结点的最近距离的顶点，并标记Visited为已经找到
	for (v = 1; v < G.numNodes; v++) {
		min = GRAPH_INFINITY; // 初始化最小距离为无穷大
		// 寻找当前未访问的顶点中距离起始点最近的顶点
		for (w = 0; w < G.numNodes; w++) {
			if (!Visited[w] && TmpDistance[w] < min) {
				UpcomingVex = w;
				min = TmpDistance[w];
			}
		}
		// 标记找到的顶点为已访问
		Visited[UpcomingVex] = true;
		// 更新从当前顶点到其他顶点的最短路径
		for (w = 0; w < G.numNodes; w++) {
			if (!Visited[w] && (min + G.arc[UpcomingVex][w] < TmpDistance[w])) {
				TmpDistance[w] = min + G.arc[UpcomingVex][w];
				Path[w] = UpcomingVex; // 记录路径
			}
		}
	}
}
// 打印从起点到各顶点的路径
void PathVexPrint(int Path[]) {
	for (int start = 0; start < MAXVEX; start++) {
		int i = start;
		char tmp[10] = "";
		int count = 0;
		// 追踪路径
		while (i >= 0) {
			tmp[count++] = 'A' + i; // 假设顶点用字母表示
			i = Path[i];
		}
		tmp[count++] = 'A'; // 添加起始点
		// 反向输出路径
		for (int j = count - 1; j >= 0; j--) {
			printf("%c", tmp[j]);
			if (j > 0) {
				printf("->");
			}
		}
		printf("\n");
	}
}

// 打印数组内容
void InfoPrint(int info[]) {
	printf("\n");
	for (int i = 0; i < MAXVEX; i++) {
		printf("%d ", info[i]);
	}
	printf("\n");
}
int main(void)
{
	MGraph G;
	/* 创建图 */
	CreateMGraph(&G);
	int TmpDistance[MAXVEX],Path[MAXVEX];
	Dijkstra(G, 0, TmpDistance,Path);
	printf("到达各顶点最短路径的长度(TmpDistance数组)为:\n");
	printf("A  B  C  D  E  F  G  H  ");
	InfoPrint(TmpDistance);
	printf("Path的值为:");
	InfoPrint(Path);
	printf("A顶点出发到达各顶点的路径如下：\n");
	PathVexPrint(Path);
	return 0;
}

无向图示意图：

84ef03cba4ba478383b338ae5884012a.png

运行结果：

Happy鱿鱼
关注
【数据结构 | C语言】Dijkstra算法（迪杰斯特拉算法）
qq_49150070的博客
03-05 2134
Dijkstra 算法 C 语言
（C语言）详细图解过程--求最短路径的方法-弗洛伊德（floyd）和迪杰斯特拉(dijkstra)
m0_54028344的博客
04-14 754
弗洛伊德（floyd）:
基于无向图且权重单一的最短路径Dijkstra算法——JAVA实现
Singleton1900的专栏
07-09 5173
做一个无向图的权重单一的最短路径算法。 模拟停车场最近车位的选择。 首先参考了博友JavaMan_chen的博文 http://blog.csdn.net/javaman_chen/article/details/8254309 但是这个算法是有问题的。 算法中，如果A点是当前点，是选取距离A点权重最小的那一点作为下一个路径点的。 这就带来了一个问题，即
最短路径之Dijkstra算法（邻接矩阵实现）
专注技术
05-21 9060
文章目录（一）Dijkstra算法 （一）Dijkstra算法 单源最短路径：是从某一个顶点出发，到图中任意顶点之间的最短路径； 【算法概述】：Dijkstra算法适用于解决单源最短路径的问题。但Dijkstra算法要求所有边的权值非负。看过Prime算法的同学都知道，Dijkstra算法与Prime算法很相似，不同的就是dis数组的更新方式。Dijkstra算法用邻接矩阵存图比较方便。 #inc...
Dijkstra算法求无向图单源最短路径(C语言实现）
06-06
程序采用读.dat文件的方式，获得顶点和弧，设置菜单栏，可供循环使用。
无向图的最短路径----迪杰斯特拉算法----（包括：花费问题，物资问题，条数问题）
九久的博客
07-22 5405
迪杰斯特拉算法如果不熟悉的话从这里开始看。。。。如果已经明白了迪杰斯特拉算法而想知道花费问题、城市之间的物资问题、最短路径条数问题的朋友可以往下翻。。。。 一、迪杰斯特拉算法讲解 算法思想是从起点开始，找到一条起点能到达顶点中的边权最小的那个点，然后从这个点开始更新起点和该点共有的点的最短路径。。思想看起来很好懂，实际编码实现还是有难度的。 我说一个我的思路： 1、初始时把图（不管是有向图...
关于用迪杰斯特拉算法求无向图最短路问题
wenrenfudi的博客
01-28 835
前言 最近在做迪杰斯特拉算法题，为了防止自己再忘了，所以还是记一下为好（惨） 一、如何用此方法求最短路 摘抄自：https://www.jianshu.com/p/01302376b8d7 如何求图中V0到V5的最短路径呢？ 第一步，根据图来建立权值矩阵： int[][] W = { { 0, 1, 4, -1, -1, -1 }, { 1, 0, 2, 7, 5, -1 }, { 4, 2, 0, -1, 1, -1 }, { -1,
c语言邻接矩阵存储有向网，使用迪杰斯特拉算法求最短路径并输出
linweiyue的博客
08-24 3058
#邻接矩阵存储有向网 在这里插入代码片
c语言实现迪杰斯特拉算法（邻接表）
李振da的碎碎念
12-25 1960
储存结构，结构体的定义：（权值w用于表示两点间路径的花费） typedef int Status; typedef struct ENode//图的邻接表定义 { int adjVex;//任意顶点u相邻接的顶点 int w;//边的权值 struct ENode* nextArc;//指向下一个边结点 }ENode; typedef struct LGraph { ...
数据结构学习笔记-Dijkstra算法(C语言邻接表实现)
guetWH的博客
05-30 1237
Dijkstra算法是计算有权值图的单源最短路径问题的经典算法 算法核心思想：定义一个顶点集合S{V0，V1，……Vn}，初始条件下集合S中只包含yu
C语言实现Dijkstra算法
09-16
本程序使用C语言实现了Dijkstra算法。程序中，定义好邻接矩阵，可以计算出任一节点到其他所有节点的最短路径，并打印路径与长度。其中对最短路径的存储是依据所得到的生成树，可以减少内存空间占用。
图论：Dijkstra算法——最详细的分析，图文并茂，一次看懂！
热门推荐
普罗米修斯的博客
08-25 8万+
Dijstra算法
无向图求最短路径——Dijkstra(迪杰斯特拉算法)
sheriMMM的博客
10-28 1万+
无向图求最短路径——Dijkstra(迪杰斯特拉算法) Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。 问题描述： 如下无向图， 若从顶点1开始计算到其余各顶点的最短路径 首先需要3个辅助数组： dist[] : 记录从顶点1开始到其余各顶点的最短路径 visited[] : 记录该顶点是否被访问过， 初始值设为0 path[] : 记录该顶点最短路径的前驱顶点 求最短路径步骤： ①初始化数组：...
MGraph图（代码、分析、汇编）
万事亨通
01-02 3731
LGraph图（代码、分析、汇编）
python算法4.11——Dijkstra/迪杰斯特拉算法（无向图）
DL_GIS
04-11 4728
特点： 单源最短路径算法，得到所有点的最短路径树 dijkstra为由路径树优化，得到最短路径树的搜索过程，这一过程的主要原则是最短枝优先，即搜索当前点到邻接点的最短节点（因此被认为是基于贪心策略）。基于这一原则可得到全局最短路径 基本步骤： 一）初始化 以图为基础，建立最短路径集合set，为搜索点集合unsearch，当前搜索节点point，通过set的最短路径到所有点的距离dis，确...
带权无向图求最短路径_迪杰斯特拉算法求最短路径（C语言详解版）
weixin_39585974的博客
01-27 4732
如今出行已经不需要再为找不着路而担心了，车上有车载导航，手机中有导航 App。只需要确定起点和终点，导航会自动规划出可行的距离最短的道路。这是最短路径在人们实际生活中最典型的应用。在一个网(有权图)中，求一个顶点到另一个顶点的最短路径的计算方式有两种：迪杰斯特拉(Dijkstra算法)和弗洛伊德(Floyd)算法。迪杰斯特拉算法计算的是有向网中的某个顶点到其余所有顶点的最短路径；弗洛伊德...
Dijkstra 最短路径算法详解 无向图
ShineRoyal
08-06 2万+
对于最短路径问题，这里介绍一种O(N^2)的求解方法。 对于求最短路径的问题一般都会给出一幅图，或者边与边的关系。如上图。假设我们起点是A，我们要求到F的最短距离，我们会怎么做？ 首先，因为A是起点，所以我们把对于每个点都有个参数，相对于A的距离，默认除了A到A为0，其他都是无穷大。 从起点A开始，我们更新与A相连通的点到A的距离，并把A点标记。如图： 我们遍历一次所有点与A的距
无向图求最短路径 迪杰斯特拉（dijkstra）算法实现
lizhiming930的专栏
10-16 4306
Dijkstra算法说明  http://ibupu.link/?id=29namespace ConsoleApp14 { class Program { public static int M = -1; static void Main(string[] args) { //源点
C语言实现的学生成绩管理系统及迪杰斯特拉算法
- 迪杰斯特拉算法简介：迪杰斯特拉（Dijkstra）算法是一种用于在加权图中找到最短路径的算法，适用于有向和无向图，且所有边的权重都必须为正。 - 算法原理：迪杰斯特拉算法采用贪心策略，通过重复选择最短路径树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值