最小生成树算法：普利姆、克鲁斯卡尔（附详细代码）

最新推荐文章于 2024-08-14 23:59:53 发布
最新推荐文章于 2024-08-14 23:59:53 发布
阅读量1.5k 收藏 20
点赞数 2
分类专栏： 图论 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40163242/article/details/105748569
版权

【注：】本文代码在c++环境下运行

普利姆算法和克鲁斯卡尔算法，都可以用于最小生成树的寻找。

初学两种算法，很容易混淆，经常会把普利姆的算法过程记到了克鲁斯卡尔的头上。这是因为这两个算法都是以人名命名，难以记忆。所以，我建议，根据两算法的特点，把克鲁斯卡尔算法记作 “加边算法” 。把普利姆算法记作 “加点算法”。

我们今天的算法分析，就以下面这个无向带权图为例子：
在这里插入图片描述
其邻接矩阵我们可以画出，如下图：
在这里插入图片描述

加边算法克鲁斯卡尔

在这里插入图片描述

就是每次选择权值最小的边加入到最小生成树集合中。当然，要满足一个前提，这条边加入进来之后，不能产生回路。

要解决的核心问题就是：1.排序；2.判断一条边的加入，会不会构成环。

核心代码：（详细代码见帖子最后）

//克鲁斯卡尔算法
void kruskal(EData **edges, PGraph G) {
	int k = 0;			//对应结果集的指针 
	EData res[MAX];		//存最小生成树结果的边
	sort(edges, G);		//对边的权值排序
	//遍历每一条边
	for(int i = 0;i < G->edgnum;i++){		
		//把每一条边的两个结点编号拿出来
		int p_start = get_index((*edges + i)->start);
		int p_end = get_index((*edges + i)->end);
		//p_start和 p_end 如果不属于同一个集合才能加入。否则加入他们就会产生回路。 
		if(G->vexs[p_start] != G->vexs[p_end]){
			res[k++] = *(*edges + i);
			//要把所有连通分量编号为 p_end的节点给置为p_start。这一步是至关重要的一步！！ 
			for(int j = 0;j < G->vexnum;j++){
				if(G->vexs[j] == G->vexs[p_end]){
					G->vexs[j] = G->vexs[p_start];
				}
			}
		}
	}
	cout << "克鲁斯卡尔算法生成的最小生成树的各边为：" << endl;
	for(int i = 0;i < k;i++){
		cout << res[i].start << ", " << res[i].end << "权值为：" << res[i].weight << endl;
	}
}

加点算法普利姆：

在这里插入图片描述
设定一个U集合，起始阶段把源点加入U集合内部，

每次把离 U集合 最近的那个结点加入U集合内，然后更新U集合到U集合外其他各点的距离，更新的过程我们称为 松弛。

再说大白话一点，每次把权值最小的外部结点加入U集合内。等所有结点都加入进U集合了，算法终止，最小生成树也成了。

核心代码：（完整代码见帖子最后）

//普利姆算法
int* prim(PGraph G, int *sum) {
	int* res = (int*)malloc(sizeof(EData) * G->vexnum);int k = 1;*sum = 0;	//res数组装每次选择加入最小生成树的结点序号 
	*res = 0;		//第一个节点作为初始节点 
	for(int i = 0;i < G->vexnum;i++){	//初始化dis数组 和 src数组 
		G->dis[i] = G->matrix[0][i];
		G->src[i] = 0;						
	}
	for(int i = 0;i < G->vexnum;i++){
		int min = MAX_INT, min_index = 0;
		//每次找出dis数组中的最小值，作为下一个节点
		for(int j = 0;j < G->vexnum;j++){
			if(G->dis[j] != 0 && G->dis[j] < min){
				min = G->dis[j];
				min_index = j;
			}
		} 
		//结果更新
		*sum = *sum + G->dis[min_index];
		G->dis[min_index] = 0;			//min_index结点就进入U集合了 
		*(res + k) = min_index;
		k++;
		//dis数组更新。根据这个最小值节点，松弛附近的权值
		for(int j = 0;j < G->vexnum;j++){
			//考虑到负权值的情况 
			if(G->matrix[min_index][j] < G->dis[j] && G->dis[j] != 0){
				G->dis[j] = G->matrix[min_index][j];
				G->src[j] = min_index;		//要更改路径 
			}
		} 
	}
	return res;
}

下面是完整可运行代码，包含所有数据结构及方法：

克鲁斯卡尔的：

#include<iostream>
#include<cstdlib>
using namespace std;

#define MAX_INT 999	 //边的最大权值，视为正无穷 
#define MAX 100		//数组最大长度 
/*数据结构*
// 邻接矩阵
*/
typedef struct _graph
{
    char vexs[MAX];       // 顶点集合
    int vexnum;           // 顶点数
    int edgnum;           // 边数
    int matrix[MAX][MAX]; // 邻接矩阵
}Graph, *PGraph;

// 边的结构体
typedef struct _EdgeData
{
    char start; // 边的起点
    char end;   // 边的终点
    int weight; // 边的权重
}EData;

/*
**/

//初始化邻接矩阵 
void init(PGraph G)
{
	//所有顶点 
	G->vexs[0] = 'A';G->vexs[1] = 'B';G->vexs[2] = 'C';G->vexs[3] = 'D';G->vexs[4] = 'E';
	G->edgnum = 7;
	G->vexnum = 5;
	//填充邻接矩阵
	G->matrix[0][1] = 9;G->matrix[0][2] = 8;G->matrix[0][3] = MAX_INT;G->matrix[0][4] = MAX_INT;
	G->matrix[1][2] = 2;G->matrix[1][3] = MAX_INT;G->matrix[1][4] = 6;
	G->matrix[2][3] = 4;G->matrix[2][4] = 5;
	G->matrix[3][4] = 3;
	//根据对称性质
	for(int i = 1;i < G->vexnum;i++){
		for(int j = 0;j < i;j++){
			G->matrix[i][j] = G->matrix[j][i];
		}	
	} 
}

void show(PGraph G)
{
	for(int i = 0;i < G->vexnum;i++){
		for(int j = 0;j < G->vexnum;j++){
			if(G->matrix[i][j] == MAX_INT)
				cout << "#" << " ";				//无穷大用#表示 
			else
				cout << G->matrix[i][j] << " ";
		}	
		cout << endl;
	} 
}

//得到该图的边集合。因为函数内部要改指针edges的值。所以要用二级指针 
void getEdges(EData **edges, PGraph G)
{
	*edges = (EData *)malloc(G->edgnum * sizeof(EData));
	int incre = 0;
	for(int i = 1;i < G->vexnum;i++){
		for(int j = 0;j < i;j++){
			if(G->matrix[i][j] != MAX_INT){
				//找到起点和终点 
				char start = G->vexs[i];
				char end = G->vexs[j];
				(*edges + incre)->start = start;
				(*edges + incre)->end = end;
				(*edges + incre)->weight = G->matrix[i][j];
				//地址往后增 
				incre++;
			}
		}	
	} 
} 

//打印所有的边 
void showEdges(EData *edges, PGraph G){
	for(int i = 0;i < G->edgnum;i++){
		cout << (edges + i)->start << ", " << (edges + i)->end << ", " << (edges + i)->weight << endl;
	}
}

//对Edge数组进行排序。采用简单选择排序算法 
void sort(EData **edge, PGraph G){
	for(int i = 0;i < G->edgnum;i++){
		int min = (*edge + i)->weight;
		int min_index = i;
		for(int j = i + 1;j < G->edgnum;j++){
			int val = (*edge + j)->weight;
			if(val < min){
				min = val;
				min_index = j;
			}
		}
		//和最小的节点交换 
		EData temp;
		temp.end = (*edge + i)->end;temp.start = (*edge + i)->start;temp.weight = (*edge + i)->weight;
		(*edge + i)->end = (*edge + min_index)->end;(*edge + i)->start = (*edge + min_index)->start;(*edge + i)->weight = (*edge + min_index)->weight;
		(*edge + min_index)->end = temp.end;(*edge + min_index)->start = temp.start;(*edge + min_index)->weight = temp.weight;
	}
}

//通过节点序号得到 其vexs的 下标 
int get_index(char vex){
	return vex - 65;
}

//克鲁斯卡尔算法
void kruskal(EData **edges, PGraph G) {
	int k = 0;			//对应结果集的指针 
	EData res[MAX];		//存最小生成树结果的边
	sort(edges, G);
	for(int i = 0;i < G->edgnum;i++){
		int p_start = get_index((*edges + i)->start);
		int p_end = get_index((*edges + i)->end);
		//p_start和 p_end 如果不属于同一个集合才能加入。否则加入他们就会产生回路。 
		if(G->vexs[p_start] != G->vexs[p_end]){
			res[k++] = *(*edges + i);
			//要把所有连通分量编号为 p_end的节点给置为p_start。这一步是至关重要的一步！！ 
			for(int j = 0;j < G->vexnum;j++){
				if(G->vexs[j] == G->vexs[p_end]){
					G->vexs[j] = G->vexs[p_start];
				}
			}
		}
	}
	cout << "克鲁斯卡尔算法生成的最小生成树的各边为：" << endl;
	for(int i = 0;i < k;i++){
		cout << res[i].start << ", " << res[i].end << "权值为：" << res[i].weight << endl;
	}
}

int main()
{
	Graph G;
	init(&G);
	//show(&G);
	EData *edges;
	getEdges(&edges, &G);
	cout << "排序前:" << endl;
	showEdges(edges, &G);
	sort(&edges, &G);
	cout << "排序后:" << endl;
	showEdges(edges, &G);
	cout << "----" << endl;
	kruskal(&edges, &G);
	free(edges);
	return 0;
}

运行效果：
在这里插入图片描述

普利姆的：

#include<iostream>
#include<cstdlib>
using namespace std;

#define MAX_INT 999	 //边的最大权值，视为正无穷 
#define MAX 100		//数组最大长度 
/*数据结构*
// 邻接矩阵
*/
typedef struct _graph
{
    char vexs[MAX];       // 顶点集合
    int vexnum;           // 顶点数
    int edgnum;           // 边数
    int matrix[MAX][MAX]; // 邻接矩阵
    int dis[MAX];		  //标记U集合到集合外各点的最小权值
	int src[MAX];	  	  //记录路径 
}Graph, *PGraph;

// 边的结构体
typedef struct _EdgeData
{
    char start; // 边的起点
    char end;   // 边的终点
    int weight; // 边的权重
}EData;

/*
**/

//初始化邻接矩阵 
void init(PGraph G)
{
	//所有顶点 
	G->vexs[0] = 'A';G->vexs[1] = 'B';G->vexs[2] = 'C';G->vexs[3] = 'D';G->vexs[4] = 'E';
	G->edgnum = 7;
	G->vexnum = 5;
	//填充邻接矩阵
	G->matrix[0][1] = 9;G->matrix[0][2] = 8;G->matrix[0][3] = MAX_INT;G->matrix[0][4] = MAX_INT;
	G->matrix[1][2] = 2;G->matrix[1][3] = MAX_INT;G->matrix[1][4] = 6;
	G->matrix[2][3] = 4;G->matrix[2][4] = 5;
	G->matrix[3][4] = 3;
	//根据对称性质
	for(int i = 1;i < G->vexnum;i++){
		for(int j = 0;j < i;j++){
			G->matrix[i][j] = G->matrix[j][i];
		}	
	} 
}

void show(PGraph G)
{
	cout << "图的邻接矩阵为:" << endl;
	for(int i = 0;i < G->vexnum;i++){
		for(int j = 0;j < G->vexnum;j++){
			if(G->matrix[i][j] == MAX_INT)
				cout << "#" << " ";				//无穷大用#表示 
			else
				cout << G->matrix[i][j] << " ";
		}	
		cout << endl;
	} 
}
//普利姆算法
int* prim(PGraph G, int *sum) {
	int* res = (int*)malloc(sizeof(EData) * G->vexnum);int k = 1;*sum = 0;	//res数组装每次选择加入最小生成树的结点序号 
	*res = 0;		//第一个节点作为初始节点 
	for(int i = 0;i < G->vexnum;i++){	//初始化dis数组 和 src数组 
		G->dis[i] = G->matrix[0][i];
		G->src[i] = 0;						
	}
	for(int i = 0;i < G->vexnum;i++){
		int min = MAX_INT, min_index = 0;
		//每次找出dis数组中的最小值，作为下一个节点
		for(int j = 0;j < G->vexnum;j++){
			if(G->dis[j] != 0 && G->dis[j] < min){
				min = G->dis[j];
				min_index = j;
			}
		} 
		//结果更新
		*sum = *sum + G->dis[min_index];
		G->dis[min_index] = 0;			//min_index结点就进入U集合了 
		*(res + k) = min_index;
		k++;
		//dis数组更新。根据这个最小值节点，松弛附近的权值
		for(int j = 0;j < G->vexnum;j++){
			//考虑到负权值的情况 
			if(G->matrix[min_index][j] < G->dis[j] && G->dis[j] != 0){
				G->dis[j] = G->matrix[min_index][j];
				G->src[j] = min_index;		//要更改路径 
			}
		} 
	}
	return res;
}

//打印最小生成树构建方案 
void showPath(int *res, PGraph G, int sum)
{
	for(int i = 0;i < G->vexnum;i++){
		if(i == 0){
			cout << "1.以" << G->vexs[*(res + i)] << "为初始结点" << endl; 
		}else{
			int node_index = *(res + i);
			int src_index = G->src[node_index]; 
			cout << i + 1 << ".连接结点" << G->vexs[node_index] << "与结点" << G->vexs[src_index] << endl;
		}
	} 
	cout << "生成的最小生成树代价和为：" << sum << endl;
}

int main()
{
	Graph G;
	init(&G);
	show(&G);
	int sum = 0;	//记录最小生成树的总和 
	int* res = prim(&G, &sum);
	showPath(res, &G, sum);
	free(res);
	return 0;
}

运行效果：
在这里插入图片描述

AAS48
关注
专栏目录
最小生成树代码实现（一）——克鲁斯卡尔算法
weixin_41832067的博客
04-05 1257
打算出两个系列，对最小生成树的原理和代码实现进行讲解。由于最小生成树的代码在很多教科书和网站都有讲解，所以这里的重点是代码的实现。本文的代码语言为C++，《大话数据结构》中用的是C语言，各位可以参考下。本文的主要实现是基于B站的up主@WAY_zhong的动画，连接为： [最小生成树(Kruskal(克鲁斯卡尔)和Prim(普里姆))算法动画演示] (https://www.bilibili.com/video/BV1Eb41177d1?from=search&seid=10206279426049
【图算法】最小生成树之克鲁斯卡尔算法
无意呢的博客
03-05 860
最小生成树   在含有n个顶点的连通图中选择n-1条边，构成一棵极小连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树。 克鲁斯卡尔算法(Kruskal) 克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。 **基本思想：**按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路。 **具体做法：**首先构造一个只含n个顶点的森林，...
最小生成树kruskarl
weixin_33738555的博客
06-08 126
最小生成树之kruskarl 最小生成树有两个算法，一个是prim，一个是kruskarl。prim算法就相当于以点为主，来找最小生成树而kruskarl算法就是着眼于边了 核心思想 1.将所有边按从小到大排序2.枚举某一条边，若与边相连的两个点不在同一个集合，就合并这两个点，不然就跳过（此处会用到并查集），不会并查集的话可以看看我以前写...
【算法】克鲁斯卡尔算法求最小生成树
最新发布
2302_78914800的博客
08-14 935
1.克鲁斯卡尔算法是用来求加权连通图的最小生成树的算法2.基本思路：为了连通 n 个顶点，按照权值从小到大的顺序选择 n-1 条边，并保证这 n-1 条边不构成回路3.具体做法：首先构造一个只含 n 个顶点的森林，然后按照权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止。
最小生成树(克鲁斯卡尔方法)
hududumo
05-12 143
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define M 20 #define MAX 20 typedef struct { int begin; int end; int weight; }edge; typedef struct { int adj; int weight...
菜鸟笔记之数据结构（23）
lb4f2525的博客
11-09 177
数据结构与算法—常用十种算法7克鲁斯卡尔算法（Kruskal） 声明：以下是学的尚硅谷网课并结合网上资料所记的笔记。可能会有一些错误，发现了会修改。 克鲁斯卡尔算法（Kruskal） 应用场景-公交站问题 算法介绍 克鲁斯卡尔（Kruskal）算法，是用来求加权连通图的最小生成树的算法。 基本思想：按照权值从大到小的顺序选择n-1条边，并保证这n-1条边不构成回路。 具体做法：首先构造一个只含n个顶点的森林，然后按权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止 。
最小生成树 克鲁斯卡尔
hhhequation的博客
05-14 116
克鲁斯卡尔方法的几个步骤 1.将所有可以进行连接的两点以及权值存入结构体中 2.对结构体进行权值由小到大的排序 3.对于结构体从零开始遍历，依次判断每个结构体的两点可否相连，直到结束 在第三步中要用到并查集，注意每一个并查集的值是和最初每一个的点对应的。 不要忘记一些小的细节，比如并查集集合的初始化，并查集的压缩，结构体遍历的提前break。 ...
最小生成树（图解普里姆算法、图解克鲁斯卡尔算法）
Ronz 的博客
02-04 7563
文章目录一、最小生成树概述1.1 背景概述1.2 最小生成树的定义1.3 最小生成树构造算法二、普里姆算法2.1 普利姆算法介绍2.2 普利姆算法代码实现三、克鲁斯卡尔算法3.1 克鲁斯卡尔算法介绍3.2 克鲁斯卡尔算法代码实现 一、最小生成树概述 1.1 背景概述 问题描述： 假设要在 n 个城市之间建立通讯联络网，则连通 n 个城市只需要修建 n-1 条线路，每条城市之间的线路修建成本是不完全相同的，如何在最节省经费的前提下建立这个通讯网？ 问题分析： n 个城市间，最多可设置 n(n-1)/2 条线路
【数据结构】最小生成树（普利姆算法和克鲁斯卡尔算法）
春雪阁
11-30 1428
主要内容 基本概念 普利姆算法（加点法） 克鲁斯卡尔算法（加边法） 现实生活中的许多问题都可以转化为图来解决。例如，如何以最小成本构建一个通信网络，如何计算地图中两地之间的最短路径，如何为复杂活动中各子任务的完成寻找一个较优的顺序等。 四个常用算法：最小生成树、最短路径、拓扑排序和关键路径。 基本概念 假设要在n个城市之间建立通信联络网，则连通n个城市只需要n-1条线路。这...
数据结构---最小生成树（普利姆算法和克鲁斯卡尔算法）
化身强盗的博客
12-19 391
存储结构 typedef struct { char vexs[MAX]; //顶点表 int arcs[MAX][MAX]; //邻接矩阵 int arc,vex; //边和点数 }Graph; //普利姆算法的closedge struct { char adjvex; int lowcost; }closedge[MAX]; //克鲁斯卡尔算法的 edge typedef struct { char head,tail; int lowcost
图的最小生成树，克鲁斯卡尔算法，普利姆算法
09-26
在这个场景下，我们将深入探讨两种经典算法：克鲁斯卡尔算法（Kruskal's Algorithm）和普利姆算法（Prim's Algorithm）。 首先，克鲁斯卡尔算法是一种贪心策略，其基本思想是从最小的边开始逐步连接顶点，但要确保...
克鲁斯卡尔构造最小生成树
07-01
克鲁斯卡尔算法构造最小生成树常见的算法，该程序是采用Kruskal算法求解最小生成树问题（邻接矩阵和邻接表）。
克鲁斯卡尔-最小生成树
qq_42811420的博客
04-28 280
克鲁斯卡尔-最小生成树 具体代码 #include<stdio.h> #define MAXEDGE 100 #define MAXVERTEX 100 typedef struct Edge { int begin;//边的起点 int end; //边的终点 int wight;//边的权值 }Edge; typedef struct Graph { char ve...
最小生成树-kruskal
海星的博客
08-10 567
      kruskal (克鲁斯卡尔) 算法与前面的 prim（普里姆）算法都是求最小生成树的算法，prim 在没有任何优化的情况下时间复杂度为O（n^2） kruskal 的时间复杂度与使用的排序算法有关 若用快排(qsort) 时间复杂度为 O（N log N） ；两者还有一个区别：prim 算法 以点为单位采用迭代的思想逐步生成最小树，kruskal 算法以边为单位 借助并查集的思想和...
克鲁斯卡尔算法生成最小生成树
ONEMORE6499的博客
03-10 3808
举个最小生成树的例子： 在一个地区有很多个小村庄，并且每个村之间都可以修路进行连通。实际上，每条路由于地形不一样，所需的经费不同，并且不可能每两个村庄都直接互通，可以间接互通，从而降低经费。如何实现呢？这时候最小生成树的作用就体现出来了。 如下图：(每个点代表一个村庄，边上的值代表修路所需经费) 生成最小生成树的方法最经典的有两种：普利姆算法和克鲁斯卡尔算法 。下面我们来说说克鲁斯卡尔算法算法...
克鲁斯卡尔算法（Kruskal）之最小生成树
浦柳人的博客
05-07 531
克鲁斯卡尔算法 求加权连通图的最小生成树的算法。 贪心求最小生成树:上代码： （C++） //#include<bits/stdc++.h> #include<stdio.h> #include<algorithm> #include<iostream> #include<stdlib.h> #include<vector>...
克鲁斯卡尔(Kruskal)算法之最小生成树
jialiang的博客
07-22 226
/** * 克鲁斯卡尔(Kruskal)算法实现最小生成树 */ public class Kruskal{ //边的个数 private int edgeNum; //顶点数组 private char[] vertexs; //邻接矩阵 private int[][] matrix; //表示两个顶点不能联通 private static final int INF = Integer.MAX_VALUE; public .
克鲁斯卡尔[最小生成树集锦]
xgogoforit的博客
08-09 346
题目链接HDU1879http://acm.hdu.edu.cn/showproblem.php?pid=1879题解状态是1的两个分量直接联通，然后套模板。##include<iostream> #include<queue> #include<cstdio> #include<cstring> #include<string> #include<cmath> #include
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值