Kruskal最小生成树(最小堆 + 并查集)

已于 2022-04-08 21:12:41 修改
阅读量585 收藏 13
点赞数 1
分类专栏： 算法导论(图论)C/C++ 文章标签： 数据结构
于 2020-03-18 18:35:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45349225/article/details/104949524
版权

伪代码
在这里插入图片描述

邻接表储存MST

/*图的邻接表结构定义*/
typedef struct ENode{
	int v1, v2;
	int Weight;
} * Edge;
struct AdjVNode{
	int AdjV;
	int Weight;
	AdjVNode *Next;
};
typedef struct VNode{
	AdjVNode *EdgeFirst;
	string Data;
} AdjList[MaxV];
typedef struct LGNode{
	int Nv, Ne;
	AdjList L;
	int Data;
} * LGraph;
LGraph CreateGraph(int Nv)
{
	LGraph G = new LGNode();
	G->Nv = Nv;
	return G;
}
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *A = new AdjVNode;
	A->AdjV = E->v2; A->Weight = E->Weight;
	A->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = A;

	A = new AdjVNode;
	A->AdjV = E->v1; A->Weight = E->Weight;
	A->Next = G->L[E->v2].EdgeFirst;
	G->L[E->v2].EdgeFirst = A;
}
void PrintMST(LGraph MST)
{
	AdjVNode *A;
	for (int i = 0; i < MST->Nv; i++)
	{
		A = MST->L[i].EdgeFirst;
		cout << i << "->";
		while (A)
		{
			cout << A->AdjV << "->";
			A = A->Next;
		}
		cout << "NULL" << endl;
	}
}
void DeleteGraph(LGraph MST)
{
	AdjVNode *A;
	for (int i = 0; i < MST->Nv; i++)
	{
		while (MST->L[i].EdgeFirst)
		{
			A = MST->L[i].EdgeFirst;
			MST->L[i].EdgeFirst = A->Next;
			delete A;
		}
	}
	delete MST;
}

最小堆及其操作

/*最小优先队列*/
typedef struct MinHeapNode{
	Edge *Data;		//最小堆存的数据是边
	int Size;
	int Capacity;
} * MinHeap;
MinHeap CreateMinHeap(int MaxSize)
{
	MinHeap H = new MinHeapNode;
	H->Size = 0;
	H->Capacity = MaxSize;
	H->Data = new Edge[MaxSize + 1];
	H->Data[0] = new ENode;
	H->Data[0]->Weight = -1;
	return H;
}
void InsertMinHeap(MinHeap H, Edge E)
{
	if(H->Size == H->Capacity)
		return;
	Edge AddE = new ENode;
	AddE->Weight = E->Weight;
	AddE->v1 = E->v1;
	AddE->v2 = E->v2;
	int x = AddE->Weight;
	int child;
	for (child = ++H->Size; x < H->Data[child / 2]->Weight; child /= 2)
		H->Data[child] = H->Data[child / 2];
	H->Data[child] = AddE;
}
Edge DeleteMinHeap(MinHeap H)
{
	if(H->Size == 0)
		return H->Data[0];
	Edge DelE = H->Data[1];
	int x = H->Data[H->Size--]->Weight;
	int parent, child;
	for ( parent = 1; parent * 2 <= H->Size; parent = child )
	{
		child = 2 * parent;
		if(H->Data[child + 1]->Weight < H->Data[child]->Weight && child != H->Size)
			child++;
		if(x > H->Data[child]->Weight)
			H->Data[parent] = H->Data[child];
		else
			break;
	}
	H->Data[parent] = H->Data[H->Size + 1];
	return DelE;
}
void DeleteHeap(MinHeap H)
{
	for (int i = 0; i <= H->Size; i++)
		delete H->Data[i];
	delete[] H->Data;
	delete H;
}

Find + Union

int FindSet(int Set[], int v)
{
	if(Set[v] < 0)
		return v;
	else
		return FindSet(Set, Set[v]);
}
void UnionSet(int Set[], int R1, int R2)	//合并集合
{
	if(Set[R1] < Set[R2])	//R1集合更多
	{
		Set[R1] += Set[R2];
		Set[R2] = R1;
	}
	else
	{
		Set[R2] += Set[R1];
		Set[R1] = R2;
	}
}

Kruskal算法

LGraph Kruskal()
{
	int Nv, Ne;
	cin >> Nv >> Ne;
	LGraph MST = CreateGraph(Nv);
	MinHeap H = CreateMinHeap(Ne);
	Edge E = new ENode;
	for (int i = 0; i < Ne; i++)
	{
		cin >> E->v1 >> E->v2 >> E->Weight;
		InsertMinHeap(H, E);
	}
	delete E;
	int *Set = new int[Nv];
	memset(Set, -1, Nv * sizeof(int));

	Edge MinE;
	while (MST->Ne < MST->Nv - 1)	//相等时，刚好所有顶点都加入生成树
	{
		MinE = DeleteMinHeap(H);
		int R1 = FindSet(Set, MinE->v1);
		int R2 = FindSet(Set, MinE->v2);
		if(R1 != R2)
		{
			UnionSet(Set, R1, R2);
			InsertEdge(MST, MinE);
			MST->Ne++;
			MST->Data += MinE->Weight;
			delete MinE;
		}
	}
	delete[] Set;
	DeleteHeap(H);
	return MST;
}

int main()
{
	LGraph MST = Kruskal();
	PrintMST(MST);
	cout << MST->Data << endl;
	DeleteGraph(MST);
	system("pause");
	return 0;
}

程序运行

input:
10 17
0 2 5
0 1 8
1 4 5
1 2 5
1 5 4
4 5 4
2 3 8
2 6 4
5 6 4
5 8 2
3 6 7
6 8 3
3 7 5
6 7 5
6 9 6
8 9 7
7 9 6
output:
0->2->NULL
1->5->NULL
2->0->6->NULL
3->7->NULL
4->5->NULL
5->4->1->8->NULL
6->7->2->8->NULL
7->9->6->3->NULL
8->6->5->NULL
9->7->NULL
38
请按任意键继续. . .

完整代码

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int MaxV = 100;

/*图的邻接表结构定义*/
typedef struct ENode{
	int v1, v2;
	int Weight;
} * Edge;
struct AdjVNode{
	int AdjV;
	int Weight;
	AdjVNode *Next;
};
typedef struct VNode{
	AdjVNode *EdgeFirst;
	string Data;
} AdjList[MaxV];
typedef struct LGNode{
	int Nv, Ne;
	AdjList L;
	int Data;
} * LGraph;
LGraph CreateGraph(int Nv)
{
	LGraph G = new LGNode();
	G->Nv = Nv;
	return G;
}
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *A = new AdjVNode;
	A->AdjV = E->v2; A->Weight = E->Weight;
	A->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = A;

	A = new AdjVNode;
	A->AdjV = E->v1; A->Weight = E->Weight;
	A->Next = G->L[E->v2].EdgeFirst;
	G->L[E->v2].EdgeFirst = A;
}
void PrintMST(LGraph MST)
{
	AdjVNode *A;
	for (int i = 0; i < MST->Nv; i++)
	{
		A = MST->L[i].EdgeFirst;
		cout << i << "->";
		while (A)
		{
			cout << A->AdjV << "->";
			A = A->Next;
		}
		cout << "NULL" << endl;
	}
}
void DeleteGraph(LGraph MST)
{
	AdjVNode *A;
	for (int i = 0; i < MST->Nv; i++)
	{
		while (MST->L[i].EdgeFirst)
		{
			A = MST->L[i].EdgeFirst;
			MST->L[i].EdgeFirst = A->Next;
			delete A;
		}
	}
	delete MST;
}
/*最小优先队列*/
typedef struct MinHeapNode{
	Edge *Data;		//最小堆存的数据是边
	int Size;
	int Capacity;
} * MinHeap;
MinHeap CreateMinHeap(int MaxSize)
{
	MinHeap H = new MinHeapNode;
	H->Size = 0;
	H->Capacity = MaxSize;
	H->Data = new Edge[MaxSize + 1];
	H->Data[0] = new ENode;
	H->Data[0]->Weight = -1;
	return H;
}
void InsertMinHeap(MinHeap H, Edge E)
{
	if(H->Size == H->Capacity)
		return;
	Edge AddE = new ENode;
	AddE->Weight = E->Weight;
	AddE->v1 = E->v1;
	AddE->v2 = E->v2;
	int x = AddE->Weight;
	int child;
	for (child = ++H->Size; x < H->Data[child / 2]->Weight; child /= 2)
		H->Data[child] = H->Data[child / 2];
	H->Data[child] = AddE;
}
Edge DeleteMinHeap(MinHeap H)
{
	if(H->Size == 0)
		return H->Data[0];
	Edge DelE = H->Data[1];
	int x = H->Data[H->Size--]->Weight;
	int parent, child;
	for ( parent = 1; parent * 2 <= H->Size; parent = child )
	{
		child = 2 * parent;
		if(H->Data[child + 1]->Weight < H->Data[child]->Weight && child != H->Size)
			child++;
		if(x > H->Data[child]->Weight)
			H->Data[parent] = H->Data[child];
		else
			break;
	}
	H->Data[parent] = H->Data[H->Size + 1];
	return DelE;
}
void DeleteHeap(MinHeap H)
{
	for (int i = 0; i <= H->Size; i++)
		delete H->Data[i];
	delete[] H->Data;
	delete H;
}
int FindSet(int Set[], int v)
{
	if(Set[v] < 0)
		return v;
	else
		return FindSet(Set, Set[v]);
}
void UnionSet(int Set[], int R1, int R2)	//合并集合
{
	if(Set[R1] < Set[R2])	//R1集合更多
	{
		Set[R1] += Set[R2];
		Set[R2] = R1;
	}
	else
	{
		Set[R2] += Set[R1];
		Set[R1] = R2;
	}
}

LGraph Kruskal()
{
	int Nv, Ne;
	cin >> Nv >> Ne;
	LGraph MST = CreateGraph(Nv);
	MinHeap H = CreateMinHeap(Ne);
	Edge E = new ENode;
	for (int i = 0; i < Ne; i++)
	{
		cin >> E->v1 >> E->v2 >> E->Weight;
		InsertMinHeap(H, E);
	}
	delete E;
	int *Set = new int[Nv];
	memset(Set, -1, Nv * sizeof(int));

	Edge MinE;
	while (MST->Ne < MST->Nv - 1)	//相等时，刚好所有顶点都加入生成树
	{
		MinE = DeleteMinHeap(H);
		int R1 = FindSet(Set, MinE->v1);
		int R2 = FindSet(Set, MinE->v2);
		if(R1 != R2)
		{
			UnionSet(Set, R1, R2);
			InsertEdge(MST, MinE);
			MST->Ne++;
			MST->Data += MinE->Weight;
			delete MinE;
		}
	}
	delete[] Set;
	DeleteHeap(H);
	return MST;
}

int main()
{
	LGraph MST = Kruskal();
	PrintMST(MST);
	cout << MST->Data << endl;
	DeleteGraph(MST);
	system("pause");
	return 0;
}
不导翁
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
运用并查集与最小堆实现Kruskal算法
razorEdge的博客
12-01 4311
前言 Kruskal是在一个图（图论）中生成最小生成树的算法之一。（另外还有Prim算法，之后会涉及到）这就牵扯到了最小生成树的概念，其实就是总权值最小的一个连通无回路的子图。（结合下文的示意图不难理解）这里的代码并没有用图的存储结构（如：矩阵，邻接链表等）来处理和运用这个算法，而是最简单的三元组输入，这样会使得这个过程简化很多，至于图的存储方式，在之后总结图数据结构的时候会具体讨论。Kruska
最小生成树kruskal算法（贪心+并查集+堆优化）
ReidSC的博客
03-10 2610
kruskal算法克鲁斯卡尔算法的基本思想是以边为主导地位，始终选择当前可用（所选的边不能构成回路）的最小权植边。所以Kruskal算法的第一步是给所有的边按照从小到大的顺序排序。这一步可以直接使用库函数qsort或者sort。接下来从小到大依次考察每一条边（u，v）。具体实现过程如下：&lt;1&gt;　设一个有n个顶点的连通网络为G（V,E），最初先构造一个只有n个顶点，没有边的非连通图T={...
【C++】【最小生成树】prim 算法实现（普里姆算法）【最小索引堆】
多丰富下自己呀
06-05 945
prim一、prim是什么？1.思想二、简易实现1.解读2.完整代码总结 一、prim是什么？ 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。 复杂度分析：E为边数，V为定点数。 1.思想 使用最小索引堆，且堆大小为节点个数。会及时更新不是横切边的边。 遍历当前节点的所有边，看这个边对面的节点。 如果对面的没有被遍历
图 之 MST（最小生成树 — kruskal算法 ）并查集实现
PeersLee的博客
12-26 4333
#并查集的优化： （1）       Find_Set(x)时，路径压缩寻找祖先时，我们一般采用递归查找，但是当元素很多亦或是整棵树变为一条链时，每次Find_Set(x)都是O(n)的复杂度。为了避免这种情况，我们需对路径进行压缩，即当我们经过”递推”找到祖先节点后，”回溯”的时候顺便将它的子孙节点都直接指向祖先，这样以后再次Find_Set(x)时复杂度就变成O(1)了，如下图所示。
Kruskal算法的C语言实现（并查集版）
jjjcainiao的专栏
05-12 3216
【问题】 Kruskal算法求加权连通图的最小生成树的算法。kruskal算法总共选择n- 1条边，所使用的贪婪准则是：从剩下的边中选择一条不会产生环路的具有最小耗费的边加入已选择的边的集合中。注意到所选取的边若产生环路则不可能形成一棵生成树。kruskal算法分e 步，其中e 是网络中边的数目。按耗费递增的顺序来考虑这e 条边，每次考虑一条边。当考虑某条边时，若将其加入到已选边的集合中会出
并查集——最小生成树算法Kruskal
长期更新Java自学笔记
07-05 1644
连通图： 在无向图中，若任意两个顶点ViV_iVi​和VjV_jVj​都有路径相通，则称该无向图为连通图强连通图： 在有向图中，若任意两个顶点ViV_iVi​和VjV_jVj​都有路径相通，则称该有向图为强连通图连通网： 在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权值，权值代表着连接各个顶点的代价，称这种连通图叫做连通网生成树： 一个连通子图，它包含连通图中全部n个顶点，有n-1条边。如果生成树中再添加一条边，则必定成环最小生成树： 在连通网的所有生成树中，所有边的代价之和最小的生成树
Prim与Kruskal算法的最小生成树matlab实现
05-26
- 迭代：遍历排序后的边，检查加入这条边是否会形成环路（通过并查集等数据结构维护边的连通性），如果不形成环路，则加入最小生成树。 - 终止条件：当树包含n-1条边（n为顶点数量）时，最小生成树构建完成。 在...
最小生成树（用堆+并查集进行优化）
12-02
例如，在Kruskal算法中，可以先按边的权重排序，然后用并查集维护连通性，当尝试添加一条边时，通过并查集快速判断是否形成环，若不形成环则添加至最小生成树。 7. **时间复杂度**： Prim算法的时间复杂度通常为O...
并查集与最小生成树 原理讲解、c++代码
10-13
并查集是一种树形数据结构，主要用于处理不相交集合的...总结来说，本篇内容介绍了并查集和最小生成树的基本原理、C++实现以及优化策略，这些数据结构和算法在解决集合关系判断和构建网络连接等问题时有着广泛的应用。
xiaoshu.rar_Kruskal 算法_最小生成树
最新发布
09-24
总的来说，Kruskal算法是一种有效的解决最小生成树问题的方法，它通过排序和并查集的结合，巧妙地避开了环路的形成，确保了生成树的最小性。在实际的图论问题和网络设计中，这种算法有着广泛的应用。
最小生成树Kruskal算法_最小生成树_
09-29
- 应用Kruskal算法，逐步选择合适的边，并更新并查集状态。 - 输出最小生成树的边集。 通过分析和运行这些MATLAB代码，我们可以更好地理解Kruskal算法的实现细节，并在实际问题中运用这一经典算法。如果你需要更...
最短路 HDU - 2544 (Dijkstra)
沐雨风栉
10-14 201
在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？ Input 输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B&
最小生成树——prim最小堆（优先队列）优化算法
Df_cjc的博客
07-29 3478
基本prim最小生成树 1·任意定点构树————标记数组标记入树 2·初始化更新维护dis数组 3·选出dis中最近的点j加入树中，并以j为起点松弛 4.重复第3步选出n-1个点 堆优化prim最小生成树 准备：dis数组，p优先队列,vis数组记录每个定点在最小堆中的位置 1.初始化优先队列，以定义的起点为起点的所有的边入队 2.弹出一条边，判断vis，如果边的终点访问了换边，直至...
最小堆+并查集实现最小生成树的kursutra算法
xutian_curry的博客
04-15 321
#include &lt;iostream&gt; #include &lt;queue&gt; #include &lt;vector&gt; using namespace std; int N,M; int father[105]; int MST; struct edage { int source,End,length; edage(int ss,int ee,int l...
最小生成树--Prim算法和Kruskal算法
beichengll的博客
08-19 2313
1、最小生成树：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。最小生成树包括三个重要的性质： 最小：边的权重和最小 生成：最小生成树是从原树生成的，包含所有顶点，|v|-1条边都在图里 树：最小生成树还必须是一棵树，无回路，V个顶点一定有|v|-1条边。 最小生成树是连通的，而连通的图一定有一个最小生成树，这是充分必要的。
kruskal算法的实现
Jssuo的博客
11-11 476
无向图中找出一颗最小生成数可以使用kruskal算法。连续地按最小的权选择边，当所选取的边不产生圈时把它作为取定的边。 Kruskal算法一般步骤： 1.选定权值最小的边。 2.判断边两端的顶点是否在同一个集合，如果不在，则此边有效，否则放弃。 3.重复上述步骤，直到将图连通。 代码如下： 优先队列部分： #ifndef BIN_HEAP_H_ #define BIN_HEA
Kruscal算法分析
lyflyf321123的专栏
07-04 879
2.最小生成树——Kruskal算法 2.1，问题描述 设G=(V,E)是无向连通带权图，如果G的一个子图G’是一棵包含G的所有顶点的树，则称G’为G的生成树。生成树的各边权的总和称为该生成树的耗费,求在G的所有生成树中耗费最小的最小生成树。 2.2，算法思想 （1）将代价树中权值非0的所有的边进行小顶堆排序，依次存入到road[]数组中，然后将road[]进行倒置，注意在
并查集和最小生成树问题的kruskal算法
T2777的博客
07-03 280
并查集解决集合的合并问题，每一个结点有一个结点号，同时存储着一个指向其双亲结点的号码，每个集合都有一个根结点，根结点的双亲节点号为-1，表示无双亲，为了查询一个结点对应的集合的根结点，可以对查询过程实现优化，在查询过程中，使得每个扫描过的结点不再指向双亲结点，而把整个集合的根结点作为自己的双亲结点即可，这样以后的查询合并过程可以大大简化，合并是并查集的主要目的，找到两个集合的根结点，使得一个根结点...
并查集、最小生成树.pptx
07-26
"该资源是一个关于并查集和最小生成树的PPT教学材料，适合于教学、复习和理解算法。标签涵盖了算法、并查集、最小生成树以及贪心策略，内容以实例解释了并查集的操作和实现。" 并查集是一种数据结构，主要用于处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值