C++ 图进阶系列之 kruskal 和 Prim 算法_图向最小生成树的华丽转身

最新推荐文章于 2024-08-03 15:53:55 发布
最新推荐文章于 2024-08-03 15:53:55 发布
阅读量682 收藏 2
点赞数
分类专栏： C++编程之美 文章标签： 算法 c++ 最小生成树 prim kruskal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y6123236/article/details/128812125
版权

1. 前言

树和图形状相似，也有差异性。树中添加一条或多条边，可成图。图中减小一条或多条边，可成树。形态的变化由数据之间的逻辑关系决定。

  • 图用来描述数据之间多对多关系。
  • 树用来描述数据之间一对多关系。

思考如下问题？

如果在一座城市城市里铺设一条地铁，要求：

  • 需求通过每一个街区。
  • 线路或造价等最短（少）。

街区之间的逻辑关系可以用无向加权图描述。建设地铁，意味着在图中查找一棵最小生成树，这样才能满足上述要求。

什么是最小生成树？

所谓最小生成村，指从图中找出一棵树，且此树满足如下几个条件：

  • 包含图中的所有顶点。
  • 树中不能有环（每个顶点仅能出现一次）。
  • 树中所有边的权重之和最小。

如果一个算法能同时解决上面的 3 个问题，则称这种算法为图的最小生树算法。

本文讲解kruskal和prim `最小树生成算法。

2. kruskal(克鲁斯卡尔)算法

2.1 算法思想

kruskal是如何解决最小生成树中的 3 个问题？

kruskal算法集结了 2 个核心思想：

  • 贪心思想。

  • 并查集思想。

贪心思想保证权重和最小

kruskal先把图中的边按权重由小到大有序排序，这里的贪心指保证每次选择权重最小的边。如果通过每次选择权重最小的边构成的树显然是权重最小的树。

并查集思想保证顶点的唯一性

树的生成是逐步过程。或者说在生成最小树过程中，有一个边界，把图中的所有顶点分成相对 2 个部分，一个是构成最小生成树的顶点集合，一个是没有加入树的顶点集合，姑且称为其它集合。

如下图所示，刚开始最小生成树集合是空的。

1.png

显然，在把图中的顶点加入到最小生成树顶点集合时，是不能把同一个顶点加入 2 次的。并查集可以做到这点。

Tips：那么，如何保证操作过程中顶点选择的唯一性?

算法使用了并查集思想。如果对并查集不是很了解，可以翻阅我的相关博文。

好！现在演示一下kruskal算法的流程。

  • 把图中的边按权重由小到大进行有序排列，且把每一个顶点当成一个独立的集合。如下图所示。

1_1.png

  • 贪心思想：选择权重最小的值为1的边(A,B) 加入到最小生成树集合中。

    并查集思想：刚开始，A和B 两顶点不在同一集合，A和B合并。

2.png

  • 现在权重为2的边有(A,C)和(B,G)，选择(A,C)边。C不在最小生成树顶点集合中，可以加入。

3.png

  • 再选择(B,G)。B在最小生成树顶点集合中，G不在，分属2个不同集合，将G加入。

4.png

  • 权重为3的边有 3 条。选择(B,F)。如下图，F加入最小生成树。

5.png

  • 权重为3的(F,G)边不能选择。因为F、G已经在同一个集合中。选择(F,E)，E加入最小生成树集合中。

6.png

  • 继续选择权重值为4的(G,D)边。D可以加入最小生成树。之后，因为C、D、E已经存在于最小生成树中，(C,D)和(D,E) 边不能加入集合中。至此，最小生成树已经完成，且最小生成树的权重之和为15。

7.png

2.1 编码实现

为了让算法具有通用性，下面使用OOP组织代码。程序中有 2 个核心类：

  • 树类。
  • 并查集类。

除此之外，还有辅助类。

2.1.1 树类实现

描述树结构。算法中要用到并查集数据结构，并查集是基于树单位的数据结构。

顶点类： 用来描述树或图的顶点结构。

#include <iostream>
#include <map>
#include <vector>
#include <queue>
using namespace std;
/*
*顶点类型
*/
template<typename T>
struct Vertex {
	//编号
	int code;
	//值
	T value;
	//前驱(父)指针
	Vertex<T>* preVertex;
	//无论是图，还是树，都有多个后驱（子）结点
	map<Vertex<T>*,int> childs;
	Vertex() {
		this->code=-1;
		this->preVertex=NULL;
	}
	Vertex(int code,T value) {
		this->code=code;
		this->preVertex=NULL;
		this->value=value;
	}
	/*
	* 添加子结点及与其权重
	*/
	Vertex<T>* addChild(Vertex<T>* vertex,int weight=1) {
		this->childs[vertex]=weight;
	}
	/*
	*重载 == 运算符
	*/
	bool operator==(Vertex<T>* vertex) {
		return this->code==vertex->code && this->value==vertex->value;
	}
	/*
	*重载 < 运算符
	*/
	bool operator<(Vertex<T>* vertex) {
		return this->code<vertex->code;
	}
	/*
	*输出结点信息
	*/
	int desc() {
		cout<<"结点名称："<<this->value<<endl;
		typename::std::map<Vertex<T>*,int>::iterator begin=this->childs.begin();
		typename::std::map<Vertex<T>*,int>::iterator end=this->childs.end();
		if(begin==end)cout<<"\t叶结点"<<endl;
		int weight=0;
		//查找子结点
		while(begin!=end) {
			Vertex<T>* child=begin->first;
			cout<<"\t子结点名称："<<child->value<<"权重："<<begin->second<<endl;
			weight+=begin->second;
			begin++;
		}
		return weight;
	}
};

树类： 提供维护树顶点的函数。

template<typename T>
class Tree {
	private:
		//根结点
		Vertex<T>* root=NULL;
		//存储所有结点
		vector<Vertex<T>*> vertexs;
		//大小
		int size=0;
		//树的权重之和
		int totalWeight=0;
	public:
		Tree() {
		}
		Tree(Vertex<T>* root) {
			this->setRoot(root);
			this->vertexs.push_back(this->root);
		}
		Tree(T val) {
			//编号从 1 开始
			this->size++;
			this->root=new Vertex<T>(this->size,val);
			this->vertexs.push_back(this->root);
		}
        //重置根结点
		void setRoot(Vertex<T>* root) {
			this->root=root;
		}
		/*
		*返回根结点
		*/
		Vertex<T>*  getRoot() {
			return this->root;
		}
		/*
		*返回树中所有结点
		*/
		vector<Vertex<T>*> getVertexs() {
			return this->vertexs;
		}
		/*
		*根据值查找结点是否存在
		*/
		Vertex<T>* findVertex(T value) {
			for(int i=0; i<this->size; i++) {
				if(this->vertexs[i]->value==value )return this->vertexs[i];
			}
			return NULL;
		}
		/*
		*查找结点是否存在
		*/
		Vertex<T>* findVertex(Vertex<T>* ver) {
			for(int i=0; i<this->vertexs.size(); i++) {
				if(this->vertexs[i]==ver )return this->vertexs[i];
			}
			return NULL;
		}

		/*
		* 根据节点值返回此树的根节点
		* 算法中，需要根据元素得知其所在的树
		* 根结点是每一棵树的唯一标志符
		*/
		Vertex<T>* getRoot(T value) {
			if(this->findVertex(value)!=NULL)return this->root;
		}
		/*
		*添加结点
		*/
		bool addVertex(Vertex<T>* ver) {
			if( this->findVertex(ver)==NULL) {
				//没有，添加
				this->vertexs.push_back(ver);
				//成功
				return true;
			}
			return false;
		}
		/*
		*合并另一颗树中的结点
		*/
		void unionTree(Tree<T>* tree) {
			//另一棵树的所有结点
			vector<Vertex<T>*> vers=tree->getVertexs();
			for(int i=0; i<vers.size(); i++)
				//合并
				this->vertexs.push_back(vers[i]);
			//修改数量
			this->size+=vers.size();
		}
		/*
		*显示树中所有结点
		*/
		void showAll() {
			cout<<"------------树 "<<this->root->value<<"------------"<<endl;
			for(int i=0; i<this->vertexs.size(); i++) {
				this->totalWeight+=this->vertexs[i]->desc();
			}
			cout<<"------------最小生成树的权重 "<<this->totalWeight<<"------------"<<endl;
		}
};
2.2.2 实现kruskal算法

本质是使用并查集合并指定边两端的顶点。

//描述图中顶点与顶点之间的关系
template<typename T>
struct Edge {
	T from;
	T to;
	int weight;
};
/*
* Kruskal 算法
*/
template<typename T>
class Kruskal {
	private:
		//集合群（森林）
		map<Vertex<T>*,Tree<T>*> trees;
		//森林中树的数量
		int size;
	public:
        /*
        *构造集合（森林）群
        */
		Kruskal(T datas[],int size) {
			this->size=size;
			this->initSets(datas);
		}
		/*
		*初始化森林
		*/
		void initSets(T datas[]) {
			for(int i=0; i<this->size; i++ ) {
				//创建只有根结点的树
				Tree<T>* tree=new Tree<T>(datas[i]);
				//存入集合群
				this->trees[tree->getRoot()]=tree;
			}
		}
		/*
		* 通过节点值查找其所在的树(集合)
		* 返回树的根结点（唯一标志符）
		*/
		Vertex<T>* find(T value) {
			typename::std::map<Vertex<T>*,Tree<T>*>::iterator begin=trees.begin();
			typename::std::map<Vertex<T>*,Tree<T>*>::iterator end=trees.end();
			while(begin!=end) {
				Tree<T> *tree=begin->second;
				Vertex<T>* root=tree->getRoot(value);
				if(root!=NULL)return root;
				begin++;
			}
			return NULL;
		}
		/*
		*合并树
		*/
		bool unionSet(T from,T to,int weight=1) {
			Vertex<T>* root =this->find(from);
			Vertex<T>* root_ =this->find(to);
            //同一棵树
			if(root==root_)return false;
			Vertex<T>* ver=this->trees[root]->findVertex(from);
			Vertex<T>* ver_=this->trees[root_]->findVertex(to);
             //合并两个顶点
			ver->addChild(ver_,weight);
			//合并树
			this->trees[root]->unionTree(this->trees[root_] );
			//删除
			this->trees.erase(root_);
			this->size--;
		}
		/*
		*查找最小生成树
		*/
		void kruskal_(Edge<T> relation[]) {
			for(int i=0; i<sizeof(relation)/sizeof(T); i++) {
				this->unionSet(relation[i].from,relation[i].to,relation[i].weight);
			}
		}
		/*
		*输出最小生成树
		*/
		void showAllTree() {
			typename::std::map<Vertex<T>*,Tree<T>*>::iterator begin=trees.begin();
			typename::std::map<Vertex<T>*,Tree<T>*>::iterator end=trees.end();
			while(begin!=end) {
				Vertex<T>* root=begin->first;
				Tree<T> *tree=begin->second;
				tree->showAll();
				begin++;
			}
		}
};

测试： 简化了图的描述，直接提供已经排序的信息，侧重测试算法设计是否准确。

int main(int argc, char** argv) {
	char datas[7]= {'A','B','C','D','E','F','G'};
    //硬代码，对图中的边按权重由小到大排序
	Edge<char> relations[9]= { {'A','B',1}, {'A','C',2},{'B','G',2},{'B','F',3},{'F','G',3},{'F','E',3},{'G','D',4},{'C','D',5},{'D','E',6} };
    //初始算法
	Kruskal<char> kruskal(datas,7);
	kruskal.kruskal_( relations);
	kruskal.showAllTree();
	return 0;
}

输出结果：和前文演示结果一致。

8.png

3. Prim(普里姆) 算法

Prim算法核心也是贪心思想，算法流程类似于最短路径算法Dijkstra算法。

相比较于kruskal，前者基于静态信息（提前对边按权重排序），后者基于动态信息（由优先队列随时调整）。

3.1 算法流程

如查询如下图结构的最小生成树。

9.png

  • 任意选择一顶点，如A。然后把与此顶点相邻的边(A,B,1)、(A,C,2)压入到优先队列中，优先队列以边的权重小为优先。如下图所示。

11.png

  • 从优先队列中选择(A,B,1)这条边，检查边两端的顶点是否已经被选择，选择B顶点。然后把B相邻的邻接边(B,G,2)、(B,F,3)压入到优先队列。

12.png

  • 从队列中选择(A,C,2)边，选择C顶点，且把C相邻边(C,D,5)压入队列。

13.png

  • 选择（B,G,2）边，选择G顶点，且把(G,F,3)、(G,D,4)压入队列。

14.png

  • 从队列中选择(B,F,3)，选择F顶点，且压入(F,E,3)边。

15.png

  • 选择(G,F,3)边，因边两端顶点都已经选择，再选择(F,E,3)边，选择E顶点，且把(E,d,6)压入队列。

16.png

17.png

  • 最后选择(G,D,4)，选择D顶点，完成最小生成树。

18.png

3.2 编码实现

顶点类和树类和前面的kruskal算法一样。

因为需要动态获取边的权重，对边类升级：

template<typename T>
struct Edge {
	Vertex<T>* from;
	Vertex<T>* to;
	int weight;
	Edge() {}
	Edge(Vertex<T>* from,Vertex<T>* to,int weight) {
		this->from=from;
		this->to=to;
		this->weight=weight;
	}
    /*
    * 用于优先队列的比较法则
    */
	bool operator() (Edge<T>* v1, Edge<T>* v2) {
		//由小到大排列
		return v1->weight > v2->weight;
	}
};

Prim 算法类：

/*
*算法类
*/
template<typename T>
class Prim {
	private:
		//优先队列容器
		priority_queue<Edge<T>* ,vector<Edge<T>*>,Edge<T> > priorityQueue;
		//图的顶点
		map<int,Vertex<T>*> graph;
		//图的邻接矩阵
		int** martix;
		//图的顶点数量
		int size;
		//最小生成树
		Tree<T>* tree;
	public:
		/*
		*构造函数
		*/
		Prim(T data[],int** martix) {
			this->size= sizeof(data)/sizeof(T);
			//初始化图顶点
			for(int i=1; i<this->size; i++ ) {
				Vertex<T>* ver=new Vertex<T>(i,data[i]);
				this->graph[ver->code]=ver;
			}
			//初始化最小生成树
			this->tree=new Tree<T>( this->graph[1]);
            //图的邻接关系
			this->martix=martix;
		}
		/*
		*查找与某顶点邻接的边,并压入队列中
		*/
		void pushQueue(Vertex<T>* ver) {
			int row=ver->code;
			Vertex<T>* to=NULL;
			for(int i=1; i<this->size; i++) {
				if(this->martix[row][i]>0) {
					to=this->graph[i];
					Edge<T>* edge=new Edge<T>(ver,to,this->martix[row][i]);
					//添加边至队列
					this->priorityQueue.push(edge);
                     //标志已经使用
					this->martix[row][i]=0;
				}
			}
		}
		/*
		*核心
		*/
		void prim() {
			//得到最小生成树的根结点
			Vertex<T>* from= this->tree->getRoot();
			//找到邻接边
			this->pushQueue(from);
			while( !this->priorityQueue.empty() ) {
				//边出队列
				Edge<T>* edge = this->priorityQueue.top();
				this->priorityQueue.pop();
				//把结点添加至树中
				if(this->tree->addVertex(edge->from)) {
                      //查找相邻边
					this->pushQueue(edge->from);
				}
				if(this->tree->addVertex(edge->to)) {
					this->pushQueue(edge->to);
					edge->from->addChild(edge->to,edge->weight);
				}
			}
		}
		void showTree() {
			this->tree->showAll();
		}
};

测试

int main(int argc, char** argv) {
	char datas[8]= {'0','A','B','C','D','E','F','G'};
	//邻接矩阵存储顶点之间的关系
	int** martix=new int*[8];
	martix[0]=new int[8] {0,0,0,0,0,0,0,0};
	martix[1]=new int[8] {0,0,1,2,0,0,0,0};
	martix[2]=new int[8] {0,1,0,0,0,0,3,2};
	martix[3]=new int[8] {0,2,0,0,5,0,0,0};
	martix[4]=new int[8] {0,0,0,5,0,6,0,4};
	martix[5]=new int[8] {0,0,0,0,6,0,3,0};
	martix[6]=new int[8] {0,0,3,0,0,3,0,3};
	martix[7]=new int[8] {0,0,2,0,4,0,3,0};
	Prim<char> prim(datas,martix);
	prim.prim();
    cout<<"Prim 最小生成树算法"<<endl;
	prim.showTree();
	return 0;
}

输出结果：

19.png

4. 总结

kruskal和Prim算法有着同工异曲之地。都是使用贪心思想，保证在构建最小生成树时，每次获得到的权重都是最小的。区别再于，kruskal使用并查集保证顶点唯一性，Prim使用广度优先搜索。

一枚大果壳
关注
专栏目录
[C++]最小生成树--Prim算法&Kruskal算法
stary_yan的博客
05-16 2万+
最小生成树–Prim算法&Kruskal算法 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。(from 百度百科） Prim算法此算法采用贪心算法的思想，运行时间为O( n^2 )。算法描述基本步骤：设R是有n个定点的对称连通关系。 1）选取R的一个
C++使用Kruskal和Prim算法实现最小生成树
12-31
很久以前就学过最小生成树之Kruskal和Prim算法，这两个算法很容易理解，但实现起来并不那么容易。最近学习了并查集算法，得知并查集可以用于实现上述两个算法后，我自己动手实现了最小生成树算法。 宏观上讲，...
数据结构C++——最小生成树之Prim算法和Kruskal算法
qq_54162207的博客
06-04 5821
数据结构C++——最小生成树之Prim算法和Kruskal算法 文章目录数据结构C++——最小生成树之Prim算法和Kruskal算法一、最小生成树的基本概念二、最小生成树之Prim算法①Prim算法的实现原理②Prim算法中的Min函数的实现③Prim算法的代码实现④测试的完整代码三、最小生成树之Kruskal算法①Kruskal算法的实现原理②Krusal算法的代码实现③测试的完整代码四、总结 一、最小生成树的基本概念 最小生成树： 在一个连通网的所有生成树中，各边的代价之和最小的那棵生成树称为该连通网
C++ 最小生成树 洛谷
最新发布
2401_86043888的博客
08-03 2086
最小生成树是个啥？其实就像杨志一行人押送生辰纲。抛开最后生辰纲被抢的结局不谈，杨志他们需要到好几个地方，每个地方都需要花点过路费给梁山好汉们打点。比如下面就是一张城市地图：其中每两个图之间的路径长就是要给梁山好汉们打点的银子数。比如。那么问题来了，。（不信？画几个图试试）众所周知，。（还是不信？画图......）所以，**我们就管这棵各边权值（费用）和叫“最小生成树”**了。那这个最小生成树到底怎么搞呢？我们伟大的先哲发明了两种算法：一种叫，另一种叫。
Kruskal算法和prim算法的C++简单实现
clggstudy的博客
09-14 978
模仿算法导论P366 和 P 367 简单实现的一个Kruskal算法。使用的数据结构 ‘不相交集合‘在P329页。图的模型简化。 Kruskal算法：基本原理：利用贪心思想，依次选择权重最小的边插入不相交集合中，即可得到最小生成树。 时间复杂度：O(ElgV) E:边的数量 V：节点数量 #include <bits/stdc++.h> //#include <unordered_map> using namespace std; class solution { ...
C++实现kruskal算法
qq_46027243的博客
10-02 6850
C++实现kruskal算法 文章目录C++实现kruskal算法1，基本思想2，注意点3，代码实现 1，基本思想 假设共有n个节点，m条边，每次从未选择过的边集E中选取权值最小的一条边，若该最小边的端点不与已选边的端点构成回路，则将该边加入到最小生成树中，重复这一步骤直到选够n-1条边或无边可选。举例如下： 图中共有9条边， 第一次：选取最小一条边，权值为1，节点v1和v3被标注； 第二次：选取最小一条边，权值为2，节点v1和v4被标注； 第三次：选取最小一条边，权值为3，节点v1和v5被标注；
最小生成树Kruskal算法实现C++实现
pleasetojava
11-08 329
// Kruskal算法实现.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; #define MAX 100 typedef int WeiType; using namespace std; // struct ...
C++ Prim算法Kruskal算法构造可以使n个城市连接的最小生成树
06-12
（1）、实验题目：给定一个地区的n 个城市间的距离网，用Prim算法或Kruskal算法建立最小生成树，并得到的最小生成树的代价。 （2）、实验要求： 1、城市间的距离网采用的邻接矩阵表示，邻接矩阵的存储结构定义采用...
Prim算法与Kruskal算法求最小生成树
07-10
最小生成树是图论中的一个重要概念，用于寻找一个无向加权图的边集合，使得这些边连接了图中的所有顶点，同时整个边集合的总权重尽可能小。在这个问题中，Prim算法和Kruskal算法是两种常用的方法。 1. Prim算法： ...
C++实现的kruskal算法（最小生成树）
二哈
06-27 3707
1. 求解最小生成树算法主要有两种，分别是prim算法与kruskal算法，下面使用的是C++语言实现的kruskal算法，之前使用Java语言描述Kruskal算法的时候已经比较详细了，博客地址为：https://blog.csdn.net/qq_39445165/article/details/9194905 2. 下面是具体的C++代码： #include<cstdio> ...
c++实现最小生成树Kruskal算法
01-19
c++实现最小生成树Kruskal算法,课程作业，供大家参考~~
最小生成树 kruskal算法 C++实现
areen7003的博客
08-22 395
#include <iostream> #include <vector> #include <algorithm> #define Inf 0x7fffffff using namespace std; struct node { int u,v; int w; node(int a,int ...
趣学算法-贪心：最小生成树
yanyanwenmeng的博客
10-22 641
校园网是为学校师生提供资源共享、信息交流和协同工作的计算机网络。校园网是一个 宽带、具有交互功能和专业性很强的局域网络。如果一所学校包括多个学院及部门，也可以 形成多个局域网络，并通过有线或无线方式连接起来。原来的网络系统只局限于以学院、图书馆为单位的局域网，不能形成集中管理以及各种资源的共享，个别学院还远离大学本部， 这些情况严重地阻碍了整个学校的网络化需求。现在需要设计网络电缆布线，将各个单位...
C++实现prim与kruskal算法
Rice__的博客
06-06 402
#pragma once #include <iostream> #include <iomanip> #include <map> using namespace std; template<class T> class MatriGraphx { public: MatriGraphx(size_t capacity = 20); ~MatriGraphx(); class Vertex//顶点 { public: Vertex(T v.
kruskal C++
qq_44664780的博客
04-17 229
1.算法简述 kruskal是基于贪心思想被设计出来的。此算法得目的是从给定得无向图中得出一棵生成树，并且此生成树得权值之和最小。举个现实中的例子，图的每个顶点都是一个城市，每条边的权值表示两个城市之间的距离，那么现在要铺设铁路，使得每个没做城市都可以互相到达，并且花费的铁轨最少，这个问题就可以用kruskal算法求解。 常见的最小生成树的算法有kruskal和prim，此文章只叙述前者。 2....
最小生成树总结(prim、并查集和kruskal) C++实现
bobkent的专栏
09-27 4289
摘要： 本文按照如下顺序进行： 1.介绍最小生成树的概念； 2.介绍prim算法的思想，以及C++实现； 3.介绍并查集概念，给出C++并查集的代码实现（因为kruskal算法必须用到并查集，所以在这里讨论一下）； 4.介绍kruskal算法思想，以及C++实现 5.附录给出prim算法、并查集和kruskal算法实现完整代码和测试程序。
最小生成树-Kruskal算法(C++实现)
qq_43269370的博客
12-01 508
最开始用Java实现，然后为了作业再用C++实现，然后就发现用C++坑太多了，改这改那的，索性这里就直接说一下注意的点，然后就贴完整代码了，想看详解的小伙伴戳链接 算法具体思路与实现详解 https://blog.csdn.net/qq_43269370/article/details/103243969 注意 C++的数组要动态分配内存，才可以实现用变量作为数组大小 一维数组 int *...
最小生成树算法———Kruskal算法（C++实现）
yourgrandfather_的博客
12-17 969
本文介绍图论中最基础的也是最重要的算法——Kruskal，有保姆级的思路讲解（保证一看就会😊），并且配有完整的模板代码（配有详细的注释），感觉来看看提升自己吧！！
c++分别用Prim算法和Kruskal算法编程实现一下连通无向图的最小生成树。
06-03
好的，下面分别给出使用 Prim 算法和 Kruskal 算法实现连通无向图的最小生成树的 C++ 代码实现。 首先，我们需要定义一个边的结构体，用于存储边的起点、终点和权重： ```c++ struct Edge { int src, dest, weight; }; ``` 接下来，我们分别实现 Prim 算法和 Kruskal 算法。 使用 Prim 算法实现最小生成树： ```c++ #include <iostream> #include <vector> #include <queue> #include <climits> using namespace std; // 定义边 struct Edge { int src, dest, weight; }; // 定义比较函数，用于优先队列 struct Compare { bool operator()(Edge const& e1, Edge const& e2) { return e1.weight > e2.weight; } }; // 定义 Prim 算法函数 void primMST(vector<vector<int>>& graph, int n) { vector<int> key(n, INT_MAX); vector<bool> mstSet(n, false); priority_queue<Edge, vector<Edge>, Compare> pq; key[0] = 0; pq.push({0, 0, 0}); while (!pq.empty()) { int u = pq.top().dest; pq.pop(); if (mstSet[u]) continue; mstSet[u] = true; for (int v = 0; v < n; v++) { if (graph[u][v] && !mstSet[v] && graph[u][v] < key[v]) { key[v] = graph[u][v]; pq.push({u, v, key[v]}); } } } int sum = 0; for (int i = 1; i < n; i++) { sum += key[i]; } cout << "Prim算法得到的最小生成树权值和为 " << sum << endl; } // 测试函数 int main() { int n = 5; vector<vector<int>> graph = { {0, 2, 0, 6, 0}, {2, 0, 3, 8, 5}, {0, 3, 0, 0, 7}, {6, 8, 0, 0, 9}, {0, 5, 7, 9, 0} }; primMST(graph, n); return 0; } ``` 使用 Kruskal 算法实现最小生成树： ```c++ #include <iostream> #include <vector> #include <algorithm> using namespace std; // 定义边 struct Edge { int src, dest, weight; }; // 定义比较函数，用于排序 bool compare(Edge const& e1, Edge const& e2) { return e1.weight < e2.weight; } // 定义 Kruskal 算法函数 void kruskalMST(vector<Edge>& edges, int n) { vector<Edge> result(n - 1); sort(edges.begin(), edges.end(), compare); vector<int> parent(n); for (int i = 0; i < n; i++) { parent[i] = i; } int e = 0, i = 0; while (e < n - 1) { Edge next_edge = edges[i++]; int x = parent[next_edge.src]; int y = parent[next_edge.dest]; if (x != y) { result[e++] = next_edge; for (int j = 0; j < n; j++) { if (parent[j] == y) { parent[j] = x; } } } } int sum = 0; for (int i = 0; i < n - 1; i++) { sum += result[i].weight; } cout << "Kruskal算法得到的最小生成树权值和为 " << sum << endl; } // 测试函数 int main() { int n = 5; vector<Edge> edges = { {0, 1, 2}, {0, 3, 6}, {1, 2, 3}, {1, 3, 8}, {1, 4, 5}, {2, 4, 7}, {3, 4, 9} }; kruskalMST(edges, n); return 0; } ``` 以上代码中，我们分别实现了 Prim 算法和 Kruskal 算法。在 Prim 算法中，我们使用了一个优先队列来维护当前最小的边，同时使用了一个 `key` 数组来记录每个节点到当前生成树的最小边权值。在 Kruskal 算法中，我们使用了一个并查集来维护当前生成树。 在测试函数中，我们定义了一个无向图，然后分别调用了 Prim 算法和 Kruskal 算法来计算最小生成树的权值和，最终输出结果。 希望这个代码能够帮助到您！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一枚大果壳

码文不易，晚上熬夜需要点咖啡钱

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

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

打赏作者

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

抵扣说明：

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

余额充值