C语言-数据结构 无向图普里姆Prim算法（邻接矩阵存储）

于 2024-08-30 21:38:34 发布
阅读量375 收藏 7
点赞数 5
文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BamBoo_Bean/article/details/141690933
版权

        Prim算法使用了贪心的思想，在算法中使用了两个数组，这两个数组会非常巧妙的操作整个算法的灵魂过程

lowcost的功能：

1.帮助算法寻找到当前距离已完成的最小生成树集合的最小的边长（找到新边）

2.在整个过程中记录新结点加入的时候，更新整个已完成的生成树中所有结点集合到剩余各个结点的最小值（更新当前已加入最小生成树结点集合状态下距离其他结点最短边值）

adjvex的功能：

1.存储每个新节点加入已完成最小生成树结点时，通过它找到当前新加入生成树结点集合中的前驱结点是谁，从而输出对应的边

2.更新前驱结点，帮助在下一次寻找到新结点保存对应的前驱结点（例如A->B这条边中A结点叫前驱）

        整个算法的过程时非常巧妙的，lowcost数组类似于水母的触手一开始就只有一条触手，通过触手找到当前最短的边，并把它捕获到已经完成的生成树结点中，理解为生成新的一条触手，触手数量+1，整个代码中大for循环中包含两个小循环，大for循环进行节点数-1轮，每一次从图中找到一个新结点，也就是找到最小生成树的一条边，里面第一个while循环找到当前距离水面触手最短的结点，也就是即将加入的最小生成树的边，找到后并把边对应的结点设置为0标记已经找到的边，下面的小循环for是为了更新当新的触手（新的边）加入的时候，整个水母触手（已完成的最小生成树）距离剩下的各结点之间最短的边长进行更新。并存入下一个即将加入水母触手伙伴的前驱结点，以便绘制打印出对应的边。

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

  最小生成树示意图：

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

        Prim算法代码：

/* Prim算法生成最小生成树  */
void MiniSpanTree_Prim(MGraph G)
{
	int min, i, j, k;
	int adjvex[MAXVEX];		/* 保存相关顶点下标 */
	int lowcost[MAXVEX];	/* 保存相关顶点间边的权值 */
	lowcost[0] = 0;/* 初始化第一个权值为0，即v0加入生成树 */
	/* lowcost的值为0，在这里就是此下标的顶点已经加入生成树 */
	adjvex[0] = 0;			/* 初始化第一个顶点下标为0 */
	for (i = 1; i < G.numNodes; i++)	/* 循环除下标为0外的全部顶点 */
	{
		lowcost[i] = G.arc[0][i];	/* 将v0顶点与之有边的权值存入数组 */
		adjvex[i] = 0;					/* 初始化都为v0的下标 */
	}
	printf("\n最小生成树的边按顺序生成：\n");
	for (i = 1; i < G.numNodes; i++)
	{
		min = GRAPH_INFINITY;	/* 初始化最小权值为∞， */
		/* 通常设置为不可能的大数字如32767、65535等 */
		j = 0; k = 0;
		while (j < G.numNodes)	/* 循环全部顶点 */
		{
			if (lowcost[j] != 0 && lowcost[j] < min)/* 如果权值不为0且权值小于min */
			{
				min = lowcost[j];	/* 则让当前权值成为最小值 */
				k = j;			/* 将当前最小值的下标存入k */
			}
			j++;
		}
		printf("(%d, %d)\n", adjvex[k], k);/* 打印当前顶点边中权值最小的边 */
		lowcost[k] = 0;/* 将当前顶点的权值设置为0,表示此顶点已经完成任务 */
		for (j = 0; j < G.numNodes; j++)	/* 循环所有顶点 */
		{
			if (lowcost[j] != 0 && G.arc[k][j] < lowcost[j])
			{/* 如果下标为k顶点各边权值小于此前这些顶点未被加入生成树权值 */
				lowcost[j] = G.arc[k][j];/* 将较小的权值存入lowcost相应位置 */
				adjvex[j] = k;				/* 将下标为k的顶点存入adjvex */
			}
		}
	}
}

完整代码（包含邻接矩阵的创建，Prim算法）

#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 GRAPH_INFINITY 99 /* 用0表示∞，表示不存在边 */

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

/* 访问标记数组 */
Boolean visited[MAXVEX];

/* 图的邻接矩阵结构体 */
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 = 12;

	// 定义顶点标签
	char Array[] = "ABCDEFGHI";

	// 初始化邻接矩阵和顶点表
	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");
	}
}

/* Prim算法生成最小生成树  */
void MiniSpanTree_Prim(MGraph G)
{
	int min, i, j, k;
	int adjvex[MAXVEX];		/* 保存相关顶点下标 */
	int lowcost[MAXVEX];	/* 保存相关顶点间边的权值 */
	lowcost[0] = 0;/* 初始化第一个权值为0，即v0加入生成树 */
	/* lowcost的值为0，在这里就是此下标的顶点已经加入生成树 */
	adjvex[0] = 0;			/* 初始化第一个顶点下标为0 */
	for (i = 1; i < G.numNodes; i++)	/* 循环除下标为0外的全部顶点 */
	{
		lowcost[i] = G.arc[0][i];	/* 将v0顶点与之有边的权值存入数组 */
		adjvex[i] = 0;					/* 初始化都为v0的下标 */
	}
	printf("\n最小生成树的边按顺序生成：\n");
	for (i = 1; i < G.numNodes; i++)
	{
		min = GRAPH_INFINITY;	/* 初始化最小权值为∞， */
		/* 通常设置为不可能的大数字如32767、65535等 */
		j = 0; k = 0;
		while (j < G.numNodes)	/* 循环全部顶点 */
		{
			if (lowcost[j] != 0 && lowcost[j] < min)/* 如果权值不为0且权值小于min */
			{
				min = lowcost[j];	/* 则让当前权值成为最小值 */
				k = j;			/* 将当前最小值的下标存入k */
			}
			j++;
		}
		printf("(%d, %d)\n", adjvex[k], k);/* 打印当前顶点边中权值最小的边 */
		lowcost[k] = 0;/* 将当前顶点的权值设置为0,表示此顶点已经完成任务 */
		for (j = 0; j < G.numNodes; j++)	/* 循环所有顶点 */
		{
			if (lowcost[j] != 0 && G.arc[k][j] < lowcost[j])
			{/* 如果下标为k顶点各边权值小于此前这些顶点未被加入生成树权值 */
				lowcost[j] = G.arc[k][j];/* 将较小的权值存入lowcost相应位置 */
				adjvex[j] = k;				/* 将下标为k的顶点存入adjvex */
			}
		}
	}
}

int main(void)
{
	MGraph G;
	/* 创建图 */
	CreateMGraph(&G);
	//Prim算法
	MiniSpanTree_Prim(G);
	return 0;
}

最小生成树示意图：

运行结果，边是按下标输出的，下标所对应的字母按ABCDEFGH顺序来表示：

Happy鱿鱼
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Prim算法之邻接矩阵实现
Rocking_Bee's Blog
08-16 1357
PRIM #include #include using namespace std; #define MAX 99999 #define LEN 101 int dist[LEN]; int map[LEN][LEN]; bool vis[LEN]; void init() {//初始化 int i,j; for(i=0; i<LEN; i++) { for
图的邻接矩阵存储方式之普里姆prim算法（最小生成树问题）
东南之风的博客
08-02 7703
假设在n个城市间建立通信网络，则联通n个城市只需要n-1条线路，这就存在n!种联通网络即生成树，那么这就要考虑怎么建立网络能使路径最短，成本最低或是权重和最小，这个问题就是最小生成树问题（minimum cost spanning tree）。而prim算法是构造最小生成树的方法之一。 为了实现这个算法，需要设置一个辅助数组closedg[i],其中有两个分量，一个存储顶点元素（边的起始点），一...
邻接矩阵 Prim算法
12-16
邻接矩阵 Prim 算法，C++完美实现，数据结构作业。
Prim算法（邻接矩阵实现）
07-14 6694
普里姆算法介绍 普里姆(Prim)算法，和克鲁斯卡尔算法一样，是用来求加权连通图的最小生成树的算法。 基本思想 对于图G而言，V是所有顶点的集合；现在，设置两个新的集合U和T，其中U用于存放G的最小生成树中的顶点，T存放G的最小生成树中的边。 从所有uЄU，vЄ(V-U) (V-U表示出去U的所有顶点)的边中选取权值最小的边(u, v)，将顶点v加入集合U中，将边(u, v)加入集合T中，如...
Prim 普里姆算法(邻接矩阵)C语言版
朱子恒的博客
12-10 2744
Prim算法的思维路线较为简单，百度基本都能看懂。但是编程还是有点难的。 整个围绕两个东西转，一个lowcost数组，一个adjvex数组，前者是用来保存当前生成树到其它顶点的权值的。 比如这个图，假设一开始是从0出发，那么首先将0这个点并入到我们的生成树中，顺便设置一遍 lowcost数组，也就是，从0开始到其它顶点的权重。那么，这里有个问题，将0并入到我们的生成树，用什么标记表示这个顶...
prim算法 图（邻接矩阵）
代码小生
01-13 540
struct a { char adjex;//边上另一个顶点 int lowcost;//边上权值 };//辅助结构体 //.lowcost设置为0表示点已经并入最小生成树中，adjex表示最小生成树中该点所在边的另一个点， void prim(graph g,char v) { int sum=0; int i,j,k,s,index,min; a closedge[mvnum]; k=locate(g,v);//返回v的下标 clo...
数据结构C语言版-普里姆算法
最新发布
07-15
本文将详细介绍如何在C语言环境下实现普里姆算法（Prim's Algorithm），该算法用于求解加权无向图中的最小生成树问题。文章包括算法的基本原理、代码实现、运行环境介绍以及具体的示例演示等内容。 #### 普里姆算法...
Prim算法计算最小生成树（无向图&邻接矩阵）_算法_数据结构_
10-02
Prim算法是一种求解加权无向图的最小生成树的经典算法，由Eugene W. Prim于1957年提出。本文将深入探讨Prim算法的原理、步骤以及C语言的实现。 **Prim算法的基本思想**： Prim算法的主要思想是从一个起始顶点开始，...
C语言-普里姆算法-数据结构
weixin_42785489的博客
02-21 1035
整理自《大话数据结构》P247 普里姆算法的核心是以点扩散点 更好适用于：边数非常多的情况 #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TR...
邻接矩阵用c语言,邻接矩阵无向图(一)之 C语言详解
weixin_39781550的博客
05-19 1174
本章介绍邻接矩阵无向图。在"图的理论基础"中已经对图进行了理论介绍，这里就不再对图的概念进行重复说明了。和以往一样，本文会先给出C语言的实现；后续再分别给出C++和Java版本的实现。实现的语言虽不同，但是原理如出一辙，选择其中之一进行了解即可。若文章有错误或不足的地方，请不吝指出！邻接矩阵无向图的介绍邻接矩阵无向图是指通过邻接矩阵表示的无向图。上面的图G1包含了"A,B,C,D,E,F,G"共7...
Prim 算法构造最小生成树 邻接矩阵
12-11
用邻接矩阵的存储方式存储图 该图为无向图 用Prim算法构造最小生成树
prim算法邻接表，邻接矩阵，无向图
07-19
生成最小树的Prim算法 邻接表，邻接矩阵，无向图
最小生成树，Prim算法的使用（邻接矩阵实现）.txt
12-30
最小生成树，Prim算法的使用（邻接矩阵实现）
邻接矩阵的基本实现
06-04
这是图的邻接矩阵,可以求各顶点,深度周游,广度周游,包括邻接矩阵的连能图和非连能图等
无向图的邻接矩阵存储及输出
11-27
无向图的邻接矩阵存储及输出无向图的邻接矩阵存储及输出
图论--Prim算法---邻接矩阵实现
-_-独行侠>_>
10-21 829
Prim算法---邻接矩阵实现                          求最小生成树。 C语言实现：   代码实现： #include #include #include #define MAX_LEN 20 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INTMAX 0xFFFF t
prim算法 邻接矩阵+邻接表版
ur_ytii的博客
01-29 868
prim算法和dijkstra算法差不多，只不过前者每次并入一个离当前集合最近的点，一个并入离原点最近的点（前提都是vis[u]=false)； prim算法从哪个点开始都可以，所以不需要参数，这里默认起点是0；返回生成树权值之和。 邻接矩阵版prim： const int maxn = 500 + 10; const int INF = 0x3fffffff; //prim bool vis[maxn] = { false }; int g[maxn][maxn], d[maxn], n; int
最小生成树之Prim算法-使用邻接矩阵实现
fdkNeverStopLearning的博客
09-13 2038
最小生成树的算法，网上有详细的介绍，这里简单谈一下关键的几个步骤： 1：prim算法和单源最短路径中的迪杰斯特拉算法很相识，也在其中借鉴了部分算法。总的来说将图上的顶点分成两部分。一部分       为树顶点（已被选入生成树的顶点）和非树顶点（还未被选入生成树的顶点）。首先选择任意一个顶点加入生成树，然后从剩      下的非树顶点中选择一个距离生成树最近的顶点加入到生成树中，并且更新其它非...
Prim算法 邻接矩阵&邻接表实现
Siumai's Blog
05-24 1001
邻接矩阵 #include <cstdio> #include <algorithm> using namespace std; #define INF 0x7FFFFFFF int G[500][500], visited[500], W[500]; int Prim( int N ) { int sumW = 0, v; for( int i = 0; ...
C语言，输入边数、结点数和权重，构建带权无向图的邻接矩阵存储结构，分别用普里姆算法和克鲁斯卡尔算法生成该图的最小生成树
06-01
好的，我来回答你的问题。 首先，我们可以使用二维数组来表示邻接矩阵。假设边数为E，结点数为V，则邻接矩阵的大小为V*V。我们可以定义一个如下的结构体来表示一条边： ``` struct Edge { int src, dest, weight; }; ``` 接下来，我们先来看普里姆算法。该算法的基本思想是从一个任意结点开始，逐步加入与当前最小生成树相邻的边，直到生成一棵包含所有结点的最小生成树。具体实现步骤如下： 1. 初始化一个空的最小生成树集合MST和一个空的结点集合visited。 2. 随机选择一个结点v，将其加入visited集合中。 3. 从visited集合中的所有结点出发，找到一条权重最小的边，该边的另一端结点不在visited集合中，将该边加入MST集合中，并将该边的另一端结点加入visited集合中。 4. 重复步骤3，直到visited集合包含所有结点。 下面是普里姆算法的C代码实现： ```c void primMST(int graph[V][V]) { int parent[V]; // 存储最小生成树中每个结点的父结点 int key[V]; // 存储每个结点到最小生成树的距离 bool visited[V]; // 标记每个结点是否已加入最小生成树 // 初始化key数组和visited数组 for (int i = 0; i < V; i++) { key[i] = INT_MAX; visited[i] = false; } // 选择第一个结点作为起点 key[0] = 0; parent[0] = -1; for (int i = 0; i < V - 1; i++) { // 找到距离最近的结点 int u = minKey(key, visited); visited[u] = true; // 更新与u相邻的结点的key值和parent for (int v = 0; v < V; v++) { if (graph[u][v] && !visited[v] && graph[u][v] < key[v]) { parent[v] = u; key[v] = graph[u][v]; } } } // 输出最小生成树 printMST(parent, graph); } ``` 其中，minKey函数用于找到距离最近的结点，代码如下： ```c int minKey(int key[], bool visited[]) { int min = INT_MAX, min_index; for (int i = 0; i < V; i++) { if (!visited[i] && key[i] < min) { min = key[i]; min_index = i; } } return min_index; } ``` 最后，我们需要实现一个函数来输出最小生成树。代码如下： ```c void printMST(int parent[], int graph[V][V]) { printf("最小生成树:\n"); for (int i = 1; i < V; i++) { printf("%d - %d: %d\n", parent[i], i, graph[i][parent[i]]); } } ``` 接下来，我们来看克鲁斯卡尔算法。该算法的基本思想是先将所有边按照权重从小到大排序，然后依次加入到最小生成树中，直到生成一棵包含所有结点的最小生成树。具体实现步骤如下： 1. 将所有边按照权重从小到大排序。 2. 初始化一个空的最小生成树集合MST，以及一个空的并查集。 3. 依次从排好序的边中取出一条边，如果该边的两个端点不在同一个连通块中，就将该边加入MST集合中，并将该边的两个端点合并到同一个连通块中。 4. 重复步骤3，直到MST集合包含所有结点。 下面是克鲁斯卡尔算法的C代码实现： ```c void kruskalMST(struct Edge edges[]) { int parent[V]; // 存储最小生成树中每个结点的父结点 for (int i = 0; i < V; i++) { parent[i] = i; } int e = 0, i = 0; struct Edge result[V]; // 按照边的权重从小到大排序 qsort(edges, E, sizeof(edges[0]), compare); while (e < V - 1 && i < E) { // 取出一条边 struct Edge next_edge = edges[i++]; // 找到该边的两个端点所在的连通块 int x = find(parent, next_edge.src); int y = find(parent, next_edge.dest); // 如果两个端点不在同一个连通块中，将该边加入MST集合中 if (x != y) { result[e++] = next_edge; union_(parent, x, y); } } // 输出最小生成树 printMST(result); } ``` 其中，find函数用于查找一个结点所在的连通块，代码如下： ```c int find(int parent[], int i) { while (parent[i] != i) { i = parent[i]; } return i; } ``` union_函数用于合并两个连通块，代码如下： ```c void union_(int parent[], int x, int y) { int xset = find(parent, x); int yset = find(parent, y); parent[xset] = yset; } ``` 最后，我们需要实现一个函数来输出最小生成树。代码如下： ```c void printMST(struct Edge result[]) { printf("最小生成树:\n"); for (int i = 0; i < V - 1; i++) { printf("%d - %d: %d\n", result[i].src, result[i].dest, result[i].weight); } } ``` 这样，我们就完成了使用普里姆算法和克鲁斯卡尔算法生成带权无向图的最小生成树的任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值