最小生成树 Prim算法实现（c语言代码）

已于 2023-05-24 17:34:44 修改
阅读量2.4k 收藏 28
点赞数 4
分类专栏： 数据结构 算法 文章标签： c语言 开发语言 数据结构 算法
于 2023-05-24 17:29:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46721967/article/details/130851421
版权
文章描述了一个使用无向图表示城市间公路交通的问题，通过输入城市和公路信息来建立邻接矩阵，并应用普里姆算法找到最小生成树，以最小化光纤铺设成本。程序包括创建图、输入处理和最小生成树的计算过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【问题描述】

城市之间的公路交通可以用一个无向图表示。如下图所示：  

顶点表示城市、边表示城市之间有公路相连，边上的权值表示城市之间的公路长度。

编程解决以下问题：

（1）输入城市信息和城市之间公路的信息，建立图的邻接矩阵存储结构

 （2）为了使城市之间能够通信，将沿公路铺设光纤，给出合理的方案，使得光纤总耗费最小。

【输入形式】

第一行输入城市，城市之间用空格分开，输入q结束。

后面若干行，每行输入两座城市及城市间的公路长度，用空格分开。输入q结束。

输入起点城市名称。
【输出形式】起点城市出发得到的最小生成树，输出格式为(起点城市, 终点城市). 

注：城市之间是英文逗号，并且没有空格。
【样例输入】

成都 西安 昆明 贵阳 武汉 株洲 q

成都 西安 842

成都 昆明 1100

成都 贵阳 967

西安 武汉 740

贵阳 武汉 1042

贵阳 株洲 607

武汉 株洲 409

q

成都

注意事项

1. 录入边信息时，由于是无向图是对称矩阵，所以邻接矩阵对称位置都要记录边的权值。

2. 每加入一个顶点，所有未加入顶点都要更新 closedge 数组的内容。

在最后附有总的代码！！！

步骤：

一、建立图的邻接矩阵存储结构

1、定义图的数组存储的结构体类型。

#define MaxVertexNum 25 /*最大顶点数设为 25*/
#define INF 32767 		/*INF 表示∞*/
typedef int EdgeType; 	/*边的权值设为整型*/
typedef struct 			/*邻接矩阵类型定义*/
{
 char vexs[MaxVertexNum][10]; 				 /*顶点表成都,武汉...*/ 
 EdgeType edges[MaxVertexNum][MaxVertexNum]; /*邻接矩阵，即边表*/ 
 int n, e; 									 /*顶点数和边数*/
 }MGraph;

2、定义创建图的存储的函数。

/*返回顶点城市在顶点数组vexs 中序号，没有该城市名返回-1*/
int VexID(MGraph *G,char VexName[]) 
{
 int i; 
 for(i = 0; i < G -> n; i ++) 
 { 
	if(strcmp(VexName, G->vexs[i]) == 0) 
		break; 
 } 
 if(i == G->n) 
 	return -1; 
 else 
 	return i;
}

void createGraph(MGraph *G)
{
 int i, j, k, l; 
 char t[10], m[10]; 
 /*记录顶点信息*/
 printf("\n 请依次输入城市名，输入 q 退出：\n");
 for(i = 0; i < MaxVertexNum; i ++) 
 {
  	printf("\n 序号为%d的城市名称：", i); 
 	scanf("%s", G->vexs[i]); 
 	/***完善下列代码****/ /*如果输入q,退出循环*/
 	if(strcmp(G->vexs[i],"q")==0)	//比较字符串 
		break; 
 	G->n++; /*记录输入顶点数目*/	
 } 
 /*初始化邻接矩阵*/ 
/***完善下列代码****/     /*邻接矩阵主对角线上元素为0，其余为INF*/
	for(i=0;i<G->n;i++)
 	{
 		for(i=0;i<G->n;i++)
 		{
 			if(i==j)
 			{
 				G->edges[i][j] = 0;
			}
			else
				G->edges[i][j] = INF;
		}
	}
	/*记录边信息*/ 
     printf("\n 请输入边的信息，输入 q 退出：\n");    
  for(i = 0; ; i ++)                                   
   { 
	   	printf("\n 起始顶点：");   
	   	scanf("%s", t);   
	   	if(strcmp(t, "q") == 0)    
	   		break;   
	   	printf("\n 终止顶点：");   
	   	scanf("%s", m);   
	   	printf("\n 边的权重：");   
	   	scanf("%d", &l);    		
	    j = VexID(G, t);   
		k = VexID(G, m); 
	   	/***完善下列代码****/  ;/*在邻接矩阵对应位置记录边的权值*/ 
		if(j!=-1 && k!=-1)
		{
			G->edges[j][k] = l;		//无向图需要双向标记 
			G->edges[k][j] = l;	
			//G->e++;				//边数加一 
		}
		else
		{
			printf("输入的顶点信息有误！");	
			i--; 
		} 
	}  
	G->e = i;                  /*记录边的数目*/   	
}

二、编写最小生成树算法。

/*定义 Closedge 数组类型，作为普里姆算法的辅助数组类型*/
typedef struct         
{  
  int adjvex;  //目标点 
  int lowcost; //到目标点的最短距离 
}Closedge; 
/*输出最小生成树的普里姆算法。*/ 
void Prim(MGraph *G,char *startCity) 
{ /*G 为图的邻接矩阵存储，startCity 是起点城市名称*/  
  /*算法将依次输出需要铺设光缆的公路*/ 
	int k, j, i, minCost;  
	Closedge closedge[MaxVertexNum]; /*定义辅助数组*/  

	int v = VexID(G, startCity);
	if(v < 0) 
	{
		printf("输入的起点城市错误!\n");
		return;
	}
	closedge[v].lowcost = 0; 	//初始化所有的最短距离为0 
	for (j = 0; j < G->n; j ++) /*初始化 closedge 数组*/
   { /***完善下列代码****/
 		if(j!=v)		
 		{
 			closedge[j].adjvex = v;					//依此将顶点存入closedge数组 
			closedge[j].lowcost = G->edges[v][j];	//依此将边存入closedge数组 
		}	
	}	
	
	for (i = 1; i < G->n; i ++)  /*依次将顶点加入到集合 U 中*/  
	{ 
		for(j = 0; j < G->n; j++)/*定位第一个没有加入到 U 中的顶点*/    
			if(closedge[j].lowcost != 0)    
			{ 
				k = j;     
				break;    
			}			
		minCost = closedge[k].lowcost; /*定位V-U集合中 lowcost最小的顶点*/	  
		for (j = 0; j < G->n; j ++)    
			if (closedge[j].lowcost < minCost && closedge[j].lowcost != 0)             
			{
		 		/***完善下列代码****/
		 		k = j;
				minCost = closedge[j].lowcost;     
			}	
		printf("(%s,%s)\n", G->vexs[closedge[k].adjvex], G->vexs[k]);  /*输出新边加入到树中的边*/  
		/***完善下列代码****/   /*将该顶点加入到集合 U*/ 
		closedge[k].lowcost = 0; 		
		for (j = 0; j < G->n; j ++)     /*更新 closedge 数组的内容*/    
		{/***完善下列代码****/
 			if((G->edges[k][j] < closedge[j].lowcost)&& (G->edges[k][j] != 0 ))
 			{
 				closedge[j].adjvex = k;
 				closedge[j].lowcost = G->edges[k][j];
			}
		}
	}  	 
}

三、编写主函数

int main(int argn,char *argv[])
{
	int select, i, j;
	char c[10];
	MGraph *G;
	char startCity[1024];
	G = (MGraph *)malloc(sizeof(MGraph));
	G->n = G->e = 0;
	createGraph(G);
	fflush(stdin);
	gets(startCity);//输入出发城市
	Prim(G, startCity);
	return 0;
}

总的代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MaxVertexNum 25 /*最大顶点数设为 25*/
#define INF 32767 		/*INF 表示∞*/
typedef int EdgeType; 	/*边的权值设为整型*/
typedef struct 			/*邻接矩阵类型定义*/
{
 char vexs[MaxVertexNum][10]; 				 /*顶点表成都,武汉...*/ 
 EdgeType edges[MaxVertexNum][MaxVertexNum]; /*邻接矩阵，即边表*/ 
 int n, e; 									 /*顶点数和边数*/
 }MGraph;
 
/*定义 Closedge 数组类型，作为普里姆算法的辅助数组类型*/
typedef struct         
{  
  int adjvex;  //目标点 
  int lowcost; //到目标点的最短距离 
}Closedge; 

 
 /*返回顶点城市在顶点数组vexs 中序号，没有该城市名返回-1*/
int VexID(MGraph *G,char VexName[]) 
{
 int i; 
 for(i = 0; i < G -> n; i ++) 
 { 
	if(strcmp(VexName, G->vexs[i]) == 0) 
		break; 
 } 
 if(i == G->n) 
 	return -1; 
 else 
 	return i;
}

void createGraph(MGraph *G)
{
 int i, j, k, l; 
 char t[10], m[10]; 
 /*记录顶点信息*/
 printf("\n 请依次输入城市名，输入 q 退出：\n");
 for(i = 0; i < MaxVertexNum; i ++) 
 {
  	printf("\n 序号为%d的城市名称：", i); 
 	scanf("%s", G->vexs[i]); 
 	/***完善下列代码****/ /*如果输入q,退出循环*/
 	if(strcmp(G->vexs[i],"q")==0)	//比较字符串 
		break; 
 	G->n++; /*记录输入顶点数目*/	
 } 
 /*初始化邻接矩阵*/ 
/***完善下列代码****/     /*邻接矩阵主对角线上元素为0，其余为INF*/
	for(i=0;i<G->n;i++)
 	{
 		for(i=0;i<G->n;i++)
 		{
 			if(i==j)
 			{
 				G->edges[i][j] = 0;
			}
			else
				G->edges[i][j] = INF;
		}
	}
	/*记录边信息*/ 
     printf("\n 请输入边的信息，输入 q 退出：\n");    
  for(i = 0; ; i ++)                                   
   { 
	   	printf("\n 起始顶点：");   
	   	scanf("%s", t);   
	   	if(strcmp(t, "q") == 0)    
	   		break;   
	   	printf("\n 终止顶点：");   
	   	scanf("%s", m);   
	   	printf("\n 边的权重：");   
	   	scanf("%d", &l);    		
	    j = VexID(G, t);   
		k = VexID(G, m); 
	   	/***完善下列代码****/  ;/*在邻接矩阵对应位置记录边的权值*/ 
		if(j!=-1 && k!=-1)
		{
			G->edges[j][k] = l;		//无向图需要双向标记 
			G->edges[k][j] = l;	
			//G->e++;				//边数加一 
		}
		else
		{
			printf("输入的顶点信息有误！");	
			i--; 
		} 
	}  
	G->e = i;                  /*记录边的数目*/   	
}


/*输出最小生成树的普里姆算法。*/ 
void Prim(MGraph *G,char *startCity) 
{ /*G 为图的邻接矩阵存储，startCity 是起点城市名称*/  
  /*算法将依次输出需要铺设光缆的公路*/ 
	int k, j, i, minCost;  
	Closedge closedge[MaxVertexNum]; /*定义辅助数组*/  

	int v = VexID(G, startCity);
	if(v < 0) 
	{
		printf("输入的起点城市错误!\n");
		return;
	}
	closedge[v].lowcost = 0; 	//初始化所有的最短距离为0 
	for (j = 0; j < G->n; j ++) /*初始化 closedge 数组*/
   { /***完善下列代码****/
 		if(j!=v)		
 		{
 			closedge[j].adjvex = v;					//依此将顶点存入closedge数组 
			closedge[j].lowcost = G->edges[v][j];	//依此将边存入closedge数组 
		}	
	}	
	
	for (i = 1; i < G->n; i ++)  /*依次将顶点加入到集合 U 中*/  
	{ 
		for(j = 0; j < G->n; j++)/*定位第一个没有加入到 U 中的顶点*/    
			if(closedge[j].lowcost != 0)    
			{ 
				k = j;     
				break;    
			}			
		minCost = closedge[k].lowcost; /*定位V-U集合中 lowcost最小的顶点*/	  
		for (j = 0; j < G->n; j ++)    
			if (closedge[j].lowcost < minCost && closedge[j].lowcost != 0)             
			{
		 		/***完善下列代码****/
		 		k = j;
				minCost = closedge[j].lowcost;     
			}	
		printf("(%s,%s)\n", G->vexs[closedge[k].adjvex], G->vexs[k]);  /*输出新边加入到树中的边*/  
		/***完善下列代码****/   /*将该顶点加入到集合 U*/ 
		closedge[k].lowcost = 0; 		
		for (j = 0; j < G->n; j ++)     /*更新 closedge 数组的内容*/    
		{/***完善下列代码****/
 			if((G->edges[k][j] < closedge[j].lowcost)&& (G->edges[k][j] != 0 ))
 			{
 				closedge[j].adjvex = k;
 				closedge[j].lowcost = G->edges[k][j];
			}
		}
	}  	 
} 



int main(int argn,char *argv[])
{
	int select, i, j;
	char c[10];
	MGraph *G;
	char startCity[1024];
	G = (MGraph *)malloc(sizeof(MGraph));
	G->n = G->e = 0;
	createGraph(G);
	fflush(stdin);
	gets(startCity);//输入出发城市
	Prim(G, startCity);
	return 0;
}

Prim算法-最小生成树（详细、易懂、含代码）
Kzj_19的博客
06-03 534
相信大家都已经能掌握Prim算法的思路了。 话不多说直接放代码！ import java.util.PriorityQueue; public class primm { public static void main(String[] args){ int[][] a = {{Integer.MAX_VALUE,5,7,Integer.MAX_VALUE,2},{5,Integer.MAX_VALUE,Integer.MAX_V
最小生成树Prim算法C语言-图解
Lazy_Goat的博客
09-29 4971
最小生成树Prim算法算法简介图解 算法简介 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，且其所有边的权值之和亦为最小。 图解 https://baike.baidu.com/item/Prim/10242166?fromtitle=Prim%E7%AE%97%E6%B3%95&fromid=10986864&fr=aladdin ...
prim算法
weixin_42616171的博客
07-27 94
#include<cstdio> #include<vector> using namespace std; const int MAXV = 1000; //最大顶点数 const int INF = 1000000000; //设INF为一个很大的数 //邻接矩阵版 int n, G[MAXV][MAXV]; //n为顶点数，MAXV为最大顶点数 int d[MAXV]; //顶点与集合S的最短距离 bool vis[MAXV] = {false}; //标记数组
最小生成树（Prim算法）代码实现
ml29895063的博客
04-07 3939
最小生成树（Prim算法）代码实现
最小生成树-Prim算法详解（含全部代码）
热门推荐
关注网络安全、云原生安全
11-10 3万+
目录 适用条件 测试所用图 算法详解 Prim算法代码 全部代码 实验结果 适用条件 加权连通图 测试所用图 所用原图及生成过程 其中，(a) 为原图，圆圈里面是节点的名称，边上的数字是边的权值。由实线连接的点就是集合U，即生成树在生成过程中加入的点。由虚线连接的点中不包含在集合U中的就是集合V-U，即待加入到生成树的点。虚线的变化就是在每次有节点加入集合U时，V-U中的点...
Prim算法生成最小生成树（附完整的代码）
执着&你
06-07 5096
​ 在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集且为无循环图，使得联通所有结点的的 w(T) 最小，则此 T 为 G 的最小生成树。 最小生成树其实是最小权重生成树的简称。 该题难度一般，关键在于理解构建的过程。最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。建议手动演绎一下运算过程，可以加深理解！！！ ...
最小生成树 Prim 算法
qq_64485082的博客
08-20 1479
4. 从T类的所有顶点出发(A,B)，与G类中的顶点相连通的边分别是权值为A->C=2,A->D=3 ,B->C=7,B->E=8 的四条边，选择权值为A->C=2那条最小的边作为最小生成树的一部分，将其所连的属于G类中的顶点C移到T类中，得到 T={A,B,C}，G={D,E,F}。2.在 G 类中任选一个顶点作为 最小生成树的起点，假设选择顶点 A，然后将顶点 A 移到 G类中，就有 T={A}，G={B,C,D,E,F}。1.将图中的所有顶点分为 T 类 和 G 类，初始状态下，T = {
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现
08-16
本文将详细介绍两种经典算法来解决最小生成树问题：Prim算法和Kruskal算法，并以C语言实现为例进行讲解。 ### Prim算法 Prim算法是一种贪心算法，其基本思想是从一个初始节点开始，逐步添加最短的边，直到连接到...
Prim算法最小生成树(C语言)
10-16
输入数据: 7 11 A B 7 A D 5 B C 8 B D 9 B E 7 C E 5 D E 15 D F 6 E F 8 E G 9 F G 11 输出: A - D : 5 D - F : 6 A - B : 7 B - E : 7 E - C : 5 E - G : 9 Total:39
最小生成树prim算法C语言 实验报告,最小生成树-普利姆(Prim)算法
weixin_32747681的博客
05-18 1851
1. 最小生成树(又名：最小权重生成树)概念：将给出的所有点连接起来(即从一个点可到任意一个点)，且连接路径之和最小的图叫最小生成树。最小生成树属于一种树形结构(树形结构是一种特殊的图)，或者说是直链型结构，因为当n个点相连，且路径和最短，那么将它们相连的路一定是n-1条。可以利用参考一个问题理解最小生成树，有n个村庄，每个村庄之间距离不同，要求村庄之间修路，每一个村庄必须与任意一个村庄联通，如何...
用Prim算法构造最小生成树
12-07
数据结构教程实验--用Prim算法构造最小生成树
最小生成树，Prim算法的使用（邻接矩阵实现）.txt
12-30
最小生成树，Prim算法的使用（邻接矩阵实现）
基于邻接矩阵存储的图的最小生成树的Prime算法
11-26
基于邻接矩阵存储的图的最小生成树的Prime算法，对学习C++和数据结构很有帮助
Prim算法求解图的最小生成树C++源代码
12-25
输入无向连通图的顶点个数边数，输出无向连通图的最小生成树的边的权重之和。
最小生成树之普里姆算法
x2656271356的博客
11-18 3478
关于城市的最短联通路径你不想了解一下吗
AcWing858-Prim算法求最小生成树（java实现）
gudada010的博客
05-29 314
AcWing858-Prim算法求最小生成树 题目描述 给定一个 n 个点 m条边的无向图，图中可能存在重边和自环，边权可能为负数。 求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。 给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|。 由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。 输入格式 第一行包含两个
Prim算法求最小生成树，c语言实现，超详解，代码清晰
m0_74114535的博客
04-08 1556
Prim算法求最小生成树，c语言实现，超详解，代码清晰
最小生成树Prim算法代码详解
elexiangchirou的博客
11-28 541
图片来源，我是复制的这个博主的照片 具体理论什么的我就不说了，网上有很多，讲的都很好，我就简单总结一下，我们设两个集合，一个是最小生成树集合T，另一个是图Graph，我们选取 集合Graph-集合T 距集合T中顶点最近的顶点 加入后，更新与刚加入顶点相连的顶点权值，这样不断重复，直到集合T顶点==图Graph中顶点。 已选那一栏就是我们上面说的集合T，可选与不可选两列和是图Graph-集合T. 代码详解: #include <iostream> #include <mem.
C语言无向图最小生成树Prim普利姆算法
gzdvdsadf的博客
09-14 3408
代码为对Prim算法实现定义的直观构造
最小生成树prim算法c语言代码
最新发布
12-20
Prim's算法是一种用于求解带权无向图中最小生成树的经典算法。以下是使用C语言实现的简单版本，它采用邻接矩阵来表示图： ```c #include #include #define V 9 // 图的顶点数 // 边的数据结构 typedef struct {...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值