【七】【数据结构】kruskal算法，求最小生成树，代码简单实现，深度解析

已于 2024-02-15 17:58:31 修改
阅读量1.3k 收藏 30
点赞数 27
分类专栏： 数据结构 文章标签： 算法 开发语言 c语言
于 2023-12-08 20:06:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74163972/article/details/134886351
版权

目录

kruskal算法思路

​编辑

代码实现

编写 边结构体

编写push函数

编写kruskal函数

完整代码

结尾

kruskal算法思路

9256fd28be814106ad59844f86b612de.png

代码实现

这个代码是在图的邻接矩阵（无项、有权）的代码的基础上，添加了kruskal最小生成树的函数，并且修改测试用例和主函数代码，图的邻接矩阵（无项、有权）的代码具体请查看 【C语言\数据结构】图之邻接矩阵（无向、有权）代码简单实现，这里就不过多赘述。

编写 边结构体

 
typedef struct {
    int start;
    int end;
    int weight;
 }edge;

创建一个边结构体，用来表示一条边的起点和终点以及权值。

编写push函数

 
void push(edge temp,edge edges[],int edgesCount){
    int index=edgesCount-1;
    while(index>=0&&edges[index].weight>temp.weight){
        edges[index+1]=edges[index];
        index--;
    }
    edges[index+1]=temp;
 }

push函数中，第一个参数是边结构体类型的变量temp，temp表示一条边。第二个参数是边结构体数组edges，按照边的权值升序存储edge数据类型，用来模拟优先队列。第三个参数是edgesCount，表示edges数组的元素个数，用来对edges数组进行尾插操作。

edges数组按照边的权值，升序存储数据，每一次添加数据，把数据插入到指定位置，从最后一个元素开始遍历，如果该权值大于插入元素的权值，就往后赋值，挪一个位置，依次循环。循环结束标志有两个，第一个是遍历完所有元素，第二个是找到了指定的位置。最后把temp插入指定位置即可。

相同结构体数据类型变量直接赋值，表示把各成员变量数据依次赋值。

编写kruskal函数

 
void kruskal(graph g) {
    int sum = 0;
    edge temp;
    edge edges[MAX];
    edge edgesGather[MAX];
    int edgesGatherCount = 0;
    int edgesCount = 0;

    for (int i = 1; i <= g.vexnum; i++) {
        for (int j = i; j <= g.vexnum; j++) {
            if (g.arcs[i][j] != 0 && g.arcs[i][j] < INFINITY) {
                temp.start = i;
                temp.end = j;
                temp.weight = g.arcs[i][j];

                push(temp, edges, edgesCount++);
            }
        }
    }

    int    gather_maxindex = 0;
    int gather[MAX] = {0};



    for (int i = 0; i < edgesCount; i++) {
        int start, end, weight;
        start = edges[i].start;
        end = edges[i].end;
        weight = edges[i].weight;

        if ((gather[start] == gather[end] && gather[start] == 0) || gather[start] != gather[end]) {
            if ((gather[start] == gather[end] && gather[start] == 0)) {
                gather[start] = ++gather_maxindex;
                gather[end] = gather_maxindex;


            } else if (gather[start] != 0 && gather[end] != 0) {
                int gathernum = gather[end];
                for (int j = 1; j <= g.vexnum; j++) {
                    if (gather[j] == gathernum) {
                        gather[j] = gather[start];
                    }
                }

            } else if (gather[end] != 0) {
                gather[start] = gather[end];
            } else if (gather[start] != 0) {
                gather[end] = gather[start];
            }
            edgesGather[edgesGatherCount].start = start;
            edgesGather[edgesGatherCount].end = end;
            edgesGatherCount++;
            sum += weight;

        }
    }
    printf("最小生成树权值和：\n%d\n", sum);
    printf("最小生成树的结构：\n");
    for (int i = 0; i < edgesGatherCount; i++) {
        printf("%d---%d\n", edgesGather[i].start, edgesGather[i].end);
    }
 }
 
    int sum=0;
    edge temp;
    edge edges[MAX];
    edge edgesGather[MAX];
    int edgesGatherCount=0;
    int edgesCount=0;

定义sum变量，用来存储最小生成树的权值和。

定义temp变量，用来表示一条边。

定义edges数组变量，用来按照权值大小升序存储边。

定义edgesGather数组，用来存储最小生成树的边信息。

定义edgesGatherCount变量，用来存储edgesGather数组的元素个数。

定义edgesCount变量，用来存储edges数组的元素个数。

 
     for(int i=1;i<=g.vexnum;i++){
        for(int j=i;j<=g.vexnum;j++){
            if(g.arcs[i][j]!=0&&g.arcs[i][j]<INFINITY){
                temp.start=i;
                temp.end=j;
                temp.weight=g.arcs[i][j];
                
                 push(temp,edges,edgesCount++);
            }
        }
    }

遍历每一条边，如果这条边存在，就把起点，终点，权值这三个信息修正到temp边中，把temp边添加到edges数组中。

这样一来，edges数组就按照权值升序，存储了每一条边的信息。

 
int    gather_maxindex=0;
    int gather[MAX]={0};

定义gather数组，用来表示每一个顶点所在的集合，例如gather[i]=x,表示顶点i在集合x中。

定义garher_maxindex变量，用来表示集合的最大表示数，当需要新表示一个集合，只需要把这个数+1之后使用就可以了。

for (int i = 0; i < edgesCount; i++) {
		int start, end, weight;
		start = edges[i].start;
		end = edges[i].end;
		weight = edges[i].weight;

		if ((gather[start] == gather[end] && gather[start] == 0) || gather[start] != gather[end]) {
			if ((gather[start] == gather[end] && gather[start] == 0)) {
				gather[start] = ++gather_maxindex;
				gather[end] = gather_maxindex;


			} else if (gather[start] != 0 && gather[end] != 0) {
				int gathernum = gather[end];
				for (int j = 1; j <= g.vexnum; j++) {
					if (gather[j] == gathernum) {
						gather[j] = gather[start];
					}
				}

			} else if (gather[end] != 0) {
				gather[start] = gather[end];
			} else if (gather[start] != 0) {
				gather[end] = gather[start];
			}
			edgesGather[edgesGatherCount].start = start;
			edgesGather[edgesGatherCount].end = end;
			edgesGatherCount++;
			sum += weight;

		}
	}

 首先必须理清一条边中，两个顶点之间的关系，要么这两个顶点在同一集合，要么这两个点在不同的集合，在相同的集合，又分为这个集合是树集或者这个集合是非树集。

在不同的集合中，分为在不同的树集中，或者一个在树集一个在非树集。

这是所有情况的分类，对于一条边我们接不接受，取决于把这条边加入到树结构中，会不会导致原本的结构不再是树，所以这条边的两个顶点不能是在相同的数集中。

        if ((gather[start] == gather[end] && gather[start] == 0) || gather[start] != gather[end]) {

 如果两个顶点在不同的集合，或者他们在相同非树集中，就表示接受这条边。

if ((gather[start] == gather[end] && gather[start] == 0)) {
                gather[start] = ++gather_maxindex;
                gather[end] = gather_maxindex;

 如果他们都在非树集中，就必须创建一个新的集合，表示把他们添加到树结构中，修改这两个顶点gather的值，这个值的取值只要是之前没有使用过的值就可以了，因为这个值只是表示一个集合，等于这个值的所有顶点都在一个集合，等于0是非树集，不等于0是树集，所以为了保证这个值没有被使用过，取使用过的值的最大值，先++再使用它。

} else if (gather[start] != 0 && gather[end] != 0) {
                int gathernum = gather[end];
                for (int j = 1; j <= g.vexnum; j++) {
                    if (gather[j] == gathernum) {
                        gather[j] = gather[start];
                    }
                }

如果这两个顶点在不同的树集中，只需要把其中一个树集中所有元素的gather值，写成另一个树集的gather表示值就可以了，这样一来两个顶点的gather值就相同了，相同表示在同一集合。遍历end所有顶点的gather值，如果等于end顶点的gather就维护成start的gather值。

} else if (gather[end] != 0) {
                gather[start] = gather[end];
            } else if (gather[start] != 0) {
                gather[end] = gather[start];
            }

如果他们是一个在树集另一个在非树集，只需要把非树集添加到指定树集就可以了。

edgesGather[edgesGatherCount].start = start;
            edgesGather[edgesGatherCount].end = end;
            edgesGatherCount++;
            sum += weight;

最后尾插这条边，把该边的权值添加到sum的值中，因为只要在树集中，最后都会变成一颗树，而不是两颗，或者其他，所以每接受一条边就添加到sum中。

 
    printf("最小生成树权值和：\n%d\n",sum);
    printf("最小生成树的结构：\n");
    for(int i=0;i<edgesGatherCount;i++){
        printf("%d---%d\n",edgesGather[i].start,edgesGather[i].end);
    }

最后输出最小生成树的权值和，并且输出最小生成的结构。

完整代码

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX 100
#define INFINITY 9999
enum graphType {DG, UG, DN, UN}; //图的类型定义：有向图，无向图，有向网，无项网
typedef char vertexType;
typedef struct {
	vertexType vexs[MAX];
	int arcs[MAX][MAX];
	int vexnum, arcnum;
	graphType kind;
} graph;

typedef struct {
	int start;
	int end;
	int weight;
} edge;

void initGraph(graph &g) {
	g.kind = UN;
	printf("输入顶点数和边数：\n");
	scanf("%d%d", &g.vexnum, &g.arcnum);
	for (int i = 1; i <= g.vexnum; i++) {
		g.vexs[i] = i;
	}
	for (int i = 1; i <= g.vexnum; i++) {
		for (int j = 1; j <= g.vexnum; j++) {
			if (i == j) g.arcs[i][j] = 0;
			else g.arcs[i][j] = INFINITY;
		}
	}
}

void createGraph(graph &g) {
	int start_index, end_index, weight;


	printf("输入每条边的起点终点下标和边的权重：\n");
	for (int i = 1; i <= g.arcnum; i++) {
		scanf("%d%d%d", &start_index, &end_index, &weight);
		g.arcs[start_index][end_index] = weight;
		g.arcs[end_index][start_index] = weight;
	}
}

void showGraph(graph &g) {
	printf("邻接矩阵：\n");
	for (int i = 1; i <= g.vexnum; i++) {
		for (int j = 1; j <= g.vexnum; j++) {
			printf("%d ", g.arcs[i][j]);
		}
		printf("\n");
	}
}

void push(edge temp, edge edges[], int edgesCount) {
	int index = edgesCount - 1;
	while (index >= 0 && edges[index].weight > temp.weight) {
		edges[index + 1] = edges[index];
		index--;
	}
	edges[index + 1] = temp;
}
void kruskal(graph g) {
	int sum = 0;
	edge temp;
	edge edges[MAX];
	edge edgesGather[MAX];
	int edgesGatherCount = 0;
	int edgesCount = 0;

	for (int i = 1; i <= g.vexnum; i++) {
		for (int j = i; j <= g.vexnum; j++) {
			if (g.arcs[i][j] != 0 && g.arcs[i][j] < INFINITY) {
				temp.start = i;
				temp.end = j;
				temp.weight = g.arcs[i][j];

				push(temp, edges, edgesCount++);
			}
		}
	}

	int	gather_maxindex = 0;
	int gather[MAX] = {0};



	for (int i = 0; i < edgesCount; i++) {
		int start, end, weight;
		start = edges[i].start;
		end = edges[i].end;
		weight = edges[i].weight;

		if ((gather[start] == gather[end] && gather[start] == 0) || gather[start] != gather[end]) {
			if ((gather[start] == gather[end] && gather[start] == 0)) {
				gather[start] = ++gather_maxindex;
				gather[end] = gather_maxindex;


			} else if (gather[start] != 0 && gather[end] != 0) {
				int gathernum = gather[end];
				for (int j = 1; j <= g.vexnum; j++) {
					if (gather[j] == gathernum) {
						gather[j] = gather[start];
					}
				}

			} else if (gather[end] != 0) {
				gather[start] = gather[end];
			} else if (gather[start] != 0) {
				gather[end] = gather[start];
			}
			edgesGather[edgesGatherCount].start = start;
			edgesGather[edgesGatherCount].end = end;
			edgesGatherCount++;
			sum += weight;

		}
	}
	printf("最小生成树权值和：\n%d\n", sum);
	printf("最小生成树的结构：\n");
	for (int i = 0; i < edgesGatherCount; i++) {
		printf("%d---%d\n", edgesGather[i].start, edgesGather[i].end);
	}
}


int main() {
	graph g;

	initGraph(g);
	createGraph(g);
	showGraph(g);
	kruskal(g);

}
/*测试用例：
5 8
1 2 1
1 5 4
1 3 3
2 4 2
4 5 4
3 4 1
2 3 2
3 5 1
*/

代码运行截图：

7cebe004e6694e93acbb8f0d22b88b43.png

612d4f34daa3487a9c490650719556d6.png

可以验证，创建出来的最小生成树长度和连接情况是没有问题的。

结尾

我们今天学习了kruskal算法求最小生成树。首先我们引入了集合的概念，gather[i]=x表示顶点i在集合x中，依次遍历图中所有的边，依次加入到edges数组中，根据权值 进行升序排序，模拟优先队列。

依次遍历edges也就是权值最小的边，然后判断这条边的两个顶点是否在同一树集，如果不在同一树集，连接这条边构成的还是树，这条边就可以接受，依次循环，一直到edges数组变量结束。不要忘记每次添加到树集的边要存储到数组中，遍历数组就可以还原最小生成树的结构哦。

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

谢谢您的支持，期待与您在下一篇文章中再次相遇！

妖精七七_
关注
专栏目录
最小生成树——Kruskal算法
小天狼星_布莱克 的博客
08-11 1379
KruskalKruskalKruskal算法是一种用于解决最小生成树问题的贪心算法。最小生成树问题是指在一个连通图中找到一棵包含所有顶点的树，且树的边权重之和最小。KruskalKruskalKruskal算法的基本思想是从图中的边集合中选择权重最小的边，并且保证选择的边不会构成环，直到选择了n−1n-1n−1条边为止（nnn为图中顶点的个数）。
Kruskal算法 最小生成树
03-08
克鲁斯卡尔算法的基本思想是以边为主导地位，始终选择当前可用（所选的边不能构成回路）的最小权植边。所以Kruskal算法的第一步是给所有的边按照从小到大的顺序排序。这一步可以直接使用库函数qsort或者sort。接下来从小到大依次考察每一条边（u，v）。 具体实现过程如下： <1>　设一个有n个顶点的连通网络为G（V,E），最初先构造一个只有n个顶点，没有边的非连通图T={V,空}，图中每个顶点自成一格连通分量。 <2>　在Ｅ中选择一条具有最小权植的边时，若该边的两个顶点落在不同的连通分量上，则将此边加入到Ｔ中；否则，即这条边的两个顶点落到同一连通分量 上，则将此边舍去（此后永不选用这条边），重新选择一条权植最小的边。 <3>　如此重复下去，直到所有顶点在同一连通分量上为止。
AcWing 859. Kruskal算法求最小生成树
Allen的博客
02-05 199
给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。 求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。 给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。 由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。 输入格...
最小生成树 —— Kruskal 克鲁斯卡尔算法
最新发布
qq_64485082的博客
08-23 2991
算法是一种用来在加权连通图中寻找最小生成树的算法，其操作对象是。1. 从加权图中的找出；初始时，所有边都不属于最小生成树，最小生成树为。2. 从不属于最小生成树的边中，判断最小边及其连接的两个顶点加入到最小生成树。a)若不形成环路，则将此最小边及其连接的顶点并入最小生成树；b)若形成环路，则永远不再看此边，然后从剩下的且不属于最小生成树的边中，寻找权值最小的边。3. 重复上述步骤，直至所有顶点均连接在一起，并没有形成环路时，最小生成树就找到了。
Kruskal算法求最小生成树（最后附完整代码）
2301_80484340的博客
04-24 325
Kruskal算法求最小生成树（最后附完整代码）
kruskal算法求最小生成树
09-29
深度遍历图并用kruskal算法求最小生成树
深度解析：生成树算法与最小生成树
最小生成树（Minimum Spanning Tree, MST）是带权重的无向图中一个特别重要的概念。MST是图中所有边的权重之和最小的生成树。这通常用于网络设计，例如最小成本的通信网络或最低造价的基础设施建设。在带权重的有向...
Java 最新数据结构与算法全面深度解析完整视频
03-27
6. 贪心算法：每一步都采取当前最好决策，但不保证全局最优，如Prim和Kruskal最小生成树算法。 7. 图论算法：如Dijkstra单源最短路径算法、Floyd-Warshall所有对最短路径算法、拓扑排序等。 8. 字符串匹配算法：如...
图的遍历与最小生成树：Kruskal算法解析
教学目标是让学生掌握图的基本概念、术语、性质，以及如何使用邻接矩阵和邻接表存储图，熟练运用DFS和BFS遍历图，理解并能够实现Dijkstra算法求最短路径，以及普里姆算法和Kruskal算法求最小生成树。通过案例分析和...
delphi 数据结构与算法 光盘原代码
01-06
- **图算法**：深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim或Kruskal）、最短路径（Dijkstra或Floyd-Warshall）。 3. **Delphi编程特性**： - **面向对象编程**：类、对象、继承、多态、封装等...
克鲁斯卡尔算法实现最小生成树解析
"这篇资源是关于数据结构与算法的讲座笔记，主要讲解了如何应用克鲁斯卡尔算法来构造最小生成树。内容涵盖了图的基本术语、图的实现、图的遍历、连通性以及图的应用。" 在图论中，克鲁斯卡尔算法（Kruskal's ...
kruskal求最小生成树
12-02
通过矩阵输入权值情况，求最小生成树，并按顺序输出每一条路
数据结构——最小生成树C代码
06-02
本人觉得此文档对学习数据结构很有帮助，推荐分享！
最小生成树MATLAB代码实现
01-08
假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含 n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。
Kruskal 算法 求最小生成树
ACM,再见！
04-10 1366
Kruskal算法基于贪心的思想，对于图G={V,E}先gouzha
Kruskal 算法求最小生成树
花开无言
06-18 381
#include #include /* for INT_MAX */ #include #include using namespace std; #include /** 并查集. */ typedef struct ufs_t { int *p; /** 树的双亲表示法*/ int size; /** 大小. */ } ufs_t; /** * @brief 创建
Kruskal：求最小生成树
Satur9的博客
05-22 575
传送门 题意：给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。 给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。 由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。 输入格式 第一行包含两个整数n和m。 接下来m行，每行包含三个整数u，v，w，表示点u和点v之间存在一条权
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

妖精七七_

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值