数据结构克鲁斯卡尔算法

已于 2022-05-09 09:30:57 修改
阅读量123 收藏
点赞数
文章标签： 算法 数据结构 蓝桥杯
于 2022-05-08 20:17:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124653691
版权 

#include <stdio.h>
#include <string.h>
#define OK 1
#define INFINITY 32767
#define MAX_VERTEX_NUM 30
#define MAXINFOLEN 30
#define ERROR 0
#define OVERFLOW -1
#define MAXVERTEXLEN 30
#define FALSE 0
#define TRUE 1
typedef int Status;
typedef enum { DG, DN, UDG, UDN }GraphKind;
typedef int VRType;
typedef int InfoType;
typedef char* VertexType;
typedef struct ArcCell
{
	VRType adj;
	InfoType* info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
	VertexType vexs[MAX_VERTEX_NUM];
	AdjMatrix arcs;
	int vexnum, arcnum;
	GraphKind kind;
}MGraph;
Status CreatGraph(MGraph* G)
{
	printf("请输入图的类型\n");
	scanf("%d", &(G->kind));
	switch (G->kind)
	{
	case DG:return(CreatDG(G)); break;
	case DN:return(CreatDN(G)); break;
	case UDG:return(CreatUDG(G)); break;
	case UDN:return(CreatUDN(G)); break;
	default: return ERROR;
	}
}
Status CreatDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for(int i=0;i<G->vexnum;i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		G->arcs[tail][head].adj = 1;
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		printf("请输入弧的权值\n");
		scanf("%d", &(G->arcs[tail][head]));
		getchar();
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatUDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		G->arcs[vex1][vex2].adj = 1;
		G->arcs[vex2][vex1].adj = 1;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}
Status CreatUDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		printf("请输入此弧权值\n");
		scanf("%d", &(G->arcs[vex1][vex2].adj));
		getchar();
		G->arcs[vex2][vex1].adj = G->arcs[vex1][vex2].adj;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}
//树的双亲表示法
typedef char* TElemType;
#define MAX_TREE_SIZE 100
typedef struct PTNode
{
	TElemType data;
	int parent;
}PTNode;
typedef struct
{
	PTNode nodes[MAX_TREE_SIZE];
	int r, n;
}PTree;
//并查集相关数据结构
typedef PTree MFSet;
int Find_MFSet(MFSet S, int i)            //找出集合S中i所在子集的根
{
	if (i < 0 || i >= S.n)
		return ERROR;
	int k = i;
	while (S.nodes[k].parent > 0)
		k = S.nodes[k].parent;
	return k;
}
Status Merge_MFSet(MFSet* S, int i, int j)
{
	int iroot = Find_MFSet(*S, i), jroot = Find_MFSet(*S, j);
	if (iroot != jroot)
	{
		if (S->nodes[iroot].parent < S->nodes[jroot].parent)
		{
			S->nodes[iroot].parent += S->nodes[jroot].parent;
			S->nodes[jroot].parent = iroot;
		}
		else
		{
			S->nodes[jroot].parent += S->nodes[iroot].parent;
			S->nodes[iroot].parent = jroot;
		}
	}
	return OK;
}
void MinSpanTree_Kruskal(MGraph G, VertexType u)
{
	MFSet S;
	S.n = G.vexnum;
	for (int i = 0; i < G.vexnum; i++)
		if (strcmp(u, G.vexs[i]) == 0)
		{
			S.r = i;
			break;
		}
	for (int i = 0; i < G.vexnum; i++)
	{
		S.nodes[i].data = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!S.nodes[i].data) exit(OVERFLOW);
		strcpy(S.nodes[i].data, G.vexs[i]);
		S.nodes[i].parent = -1;
	}
	int count = 1;
	while (count < G.vexnum)
	{
		int minrow, mincol, min = INFINITY;
		for (int i = 0; i < G.vexnum; i++)
		{
			for (int j = i; j < G.vexnum; j++)
			{
				if (G.arcs[i][j].adj && G.arcs[i][j].adj < min)
				{
					minrow = i;
					mincol = j;
					min = G.arcs[i][j].adj;
				}
			}
		}
		G.arcs[minrow][mincol].adj = 0;
		if (Find_MFSet(S, minrow) != Find_MFSet(S, mincol))
		{
			printf("将%s与%s连起来\n", G.vexs[minrow], G.vexs[mincol]);
			Merge_MFSet(&S, minrow, mincol);
			count++;
		}
	}
}
//克鲁斯卡尔算法主函数
int main()
{
	MGraph G;
	CreatGraph(&G);
	printf("\t");
	for (int i = 0; i < G.vexnum; i++)
		printf("V%d\t", i + 1);
	printf("\n\n");
	for (int i = 0; i < G.vexnum; i++)
	{
		printf("V%d\t", i + 1);
		for (int j = 0; j < G.vexnum; j++)
			printf("%d\t", G.arcs[i][j].adj);
		printf("\n\n\n");
	}
	char* u = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!u) exit(OVERFLOW);
	strcpy(u, G.vexs[0]);
	MinSpanTree_Kruskal(G, u);
	return 0;
}

原图：

kruskal

 输入：

3
6 10 0
V1
V2
V3
V4
V5
V6
V1
V2
6
V1
V3
1
V1
V4
5
V2
V3
5
V3
V4
5
V2
V5
3
V3
V5
6
V5
V6
6
V3
V6
4
V4
V6
2

结果：

哆啦BCD梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
严蔚敏数据结构图的深度与广度优先遍历
laohuchishizi的博客
05-08 453
深度广度优先
最小生成树-Prim算法（参考 清华大学 《数据结构》 严蔚敏版）
Jasonchen1224的博客
01-28 246
最小生成树 Prim算法（参考 清华大学 《数据结构》 严蔚敏版）
Prim算法构造最小生成树
戒
03-08 4666
Prim算法 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。 1.问题 举一个实例，画出采用Prim算法构造最小生成树的过程。 2.解析 已知图V = {…} 我们构造一棵最小生成树T 第一步：随意选取起点 第二步：在前一步的基础上寻找最小权值 第三步：继续寻找最小权值，之后以此类推，直到遍历完所有的节点。 实例： 图v如图 1.任意选择一个点 这里我们选择A点 从A点出发有两条路，一条通向B(权值为3)，一条通向D(权值为4) 我们选择权值较小的点B 此时被选中的点：A
数据结构 第五章 图——最小生成树，Prim算法，Kruskal算法
qq_40344308的博客
04-27 371
生成树： 生成树是一个图的极小连通分量： （1）包含图中所有顶点； （2）只含最少的边，如果增加一条边则会构成回路，减少一条边则会不连通（因为树是一种特殊的图，树一定是连通的，而且树中不会有回路）。 最小生成树（Minimum Spanning Tree, MST）： （1）带权连通无向图； （2）图的所有生成树中各边权值之和最小的一颗生成树。 特点： （1）一个图得最小生成树是不唯一的，但最小生...
ZJOI2019Round#1
weixin_30487317的博客
03-27 984
考的这么差二试基本不用去了 不想说什么了。就把这几天听课乱记的东西丢上来吧 这里是二试乱听课笔记ZJOI2019Round#2 ZJOI Round#1 Day1 M.《具体数学》选讲 罗煜翔-宁波市镇海中学 上升/下降阶乘幂 差分和和式 差分类似求导；和式类似积分 下降幂多项式与下降幂级数 考虑如何计算两个下降幂多项式的乘积 如何处理下降幂多项式的点值？ 下降幂级数在自然数处收敛，在其他数位...
数据结构实验代码克鲁斯卡尔算法.rar
最新发布
05-01
《克鲁斯卡尔算法在数据结构实验中的应用》 数据结构是计算机科学中至关重要的一环，它涉及到如何高效地组织和存储数据以便于快速访问和处理。克鲁斯卡尔算法（Kruskal's Algorithm）是图论领域的一种经典算法，...
克鲁斯卡尔算法.zip
07-04
克鲁斯卡尔算法是图论中的一个重要算法，用于寻找加权无向图的最小生成树。这个算法由美国数学家莫里斯·克鲁斯卡尔在1956年提出，其核心思想是按照边的权重从小到大进行排序，依次添加边到当前的生成树中，但必须...
kr.rar_克鲁斯卡尔_克鲁斯卡尔算法
09-24
在实现克鲁斯卡尔算法时，通常会用到以下数据结构： - **边结构**：存储每条边的两个顶点以及权重。 - **优先队列**（如堆）：用于快速获取最小权重的边。 - **并查集**（Disjoint Set）：用于判断两个顶点是否属于...
克鲁斯卡尔算法.rar
07-06
克鲁斯卡尔算法的基本步骤如下： 1. 将图中的所有边按权重从小到大排序。 2. 初始化一个空的边集合，用于构建最小生成树。 3. 遍历排序后的边，对于每一条边(e)，检查它连接的两个顶点是否已经在当前的边集合中形成...
PHP实现克鲁斯卡尔算法实例解析
12-17
在PHP中实现克鲁斯卡尔算法，首先需要对图的数据结构进行定义。通常，图可以表示为顶点（vertices）和边（edges）的集合。在这个实例中，`EdgeArc` 类用来表示边，包含起始点、结束点和边的权重。`Edge` 类则用于...
普里姆(Prim)算法，数据机构，c语言，严蔚敏
12-31
16、输入任意的一个网，用普里姆(Prim)算法构造最小生成树。 ，数据机构，c语言，严蔚敏
克鲁斯卡尔算法
c__chong的博客
05-28 7898
什么是克鲁斯卡尔算法 在知道克鲁斯卡尔算法之前我们先来看一下什么是最小生成树。 最小生成树：在一个有n个结点的无向图中选出最少的边，保证所选边权相加之和最小以及该图中依然有n个结点并且n个结点连通。 一共有n个结点，要保证连通，至少需要n-1条边。 最小生成树的权值：w(t)=∑(u,v)∈tw(u,v)w(t)=\sum\limits_{(u,v)\in t}^{}w(u,v)w(t)=(u,v)∈t∑​w(u,v) 下面我们用图看一下什么是最小生成树： 在该图中，我们留下这四条边就可以保证各个结点
2020-10-14 //严蔚敏《数据结构》 //最小生成树--Prim算法
weixin_45888287的博客
10-14 655
//严蔚敏《数据结构》 //最小生成树--Prim算法 //自学中，加油！ #include<iostream> #include<string> using namespace std; const int MaxVertexnum=20; const int Infinity=INT_MAX; #define InfoType string #define VRType double #define VertexType string typedef enum{DG,DN,UDG
图的深度优先遍历-C语言实现
热门推荐
鲍礼彬的CSDN博客 ~_~
10-16 3万+
#include #include #include #include #define MAXLIN 40 /*----邻接表存储结构---*/ //-----------------表节点存储结构---------- typedef struct ArcNode{                                            //结构体     int a
全局最小割 stoer-wagner与karger-stein算法
weixin_34402408的博客
12-19 1031
stoer-wagner算法 进行n轮操作，每轮操作确定一对点s,t被割开情况下的最小割，然后将s,t合并。s,t为操作中最后剩下的两个点。 操作类似prim求最大生成树，每次将与当前集合相邻的距离最大的点合并到集合中，最后剩下s,t两点。 代码来自wiki const int maxn = 550; const int inf = 1000000000; int n, r;...
无向图最小割的相关算法及其延伸
hqd_acm的专栏
09-29 1813
无向图最小割的相关算法及其延伸<br />这个题目实在太大了，因为这是一个研究了许多年发表了无数篇文章的问题，我自然也无法在短期内很好的诠释它。但为了与网上的其它文章有所区别，我打算把几个内容都揉到文章中去，但是这些都似乎在ICPC中尚无用武之地，就权当是爱好吧。<br />网络流算法自然是可以解决该问题，但是我们不作讨论。还有一类方法是90年代初期发展起来以缩图（Contraction algorithm）为基础的算法，目前最简单最高效的stoer-wagner算法是1997年发表的，它的主要思想如下：<
严蔚敏-图-存储结构-图的遍历
CodePandas
02-10 1524
数据结构学习笔记【第7章 图】 7.1 图的定义和术语 图是一种较线性表和树更为复杂的数据结构。在图形结构中，结点之间的关系是任意的，图中任意两个数据元素之间都可能相关。 在图中的数据元素通常称做顶点(Vertex)，V是顶点的有穷非空集合；VR是两个顶点之间的关系的集合。若<v,w>∈VR<v,w>∈VR<v,w>∈VR，则<v,w><v,...
最小生成树之prim算法
闲云野鹤的专栏
11-26 1029
转载地址：http://blog.chinaunix.net/uid-25324849-id-2182922.html 边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小
最小生成树———prim算法和kruskal算法详解
SYITwin的博客
08-23 1万+
最小生成树之prim算法（转载出处） 边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。    构造网的最小生成树必须解决下面两个问题：     1、尽可能选取...
图数据结构详解：克鲁斯卡尔算法实现与概念解析
"本文主要介绍了数据结构中的图概念以及克鲁斯卡尔算法（Kruskal's Algorithm）在解决最小生成树问题上的应用。" 在计算机科学中，数据结构是存储和组织数据的一种方式，而图是数据结构的一种重要类型。图由顶点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值