C语言数据结构与算法---最小生成树(克鲁斯卡尔算法)

一.克鲁斯卡尔(Kruskal)算法

1.算法思想

  1. 设连通网 N = (V,E) ,令最小生成树初始状态为只有 n 个顶点而无边的非连通图 T=(V,{}),每个顶点自成一个连通分量
    在这里插入图片描述
  2. 在 E 中选取代价最小的边,若该边依附的顶点落在 T 中不同的分量上(即:不能成环),则将此边加入到 T 中;否则,舍去此边,选取下一条代价最小的边

在这里插入图片描述
3. 依次类推,直至 T 中所有顶点都在同一连通分量上为止
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
此时会发现,权值为5的有3条边,但是有两条边不符合(会构成回路)故:
在这里插入图片描述

2. 克鲁斯卡尔算法的实现

边集数组的结构:

typedef struct
{
	int begin;
	int end;
	int weight;
}Edge

在这里插入图片描述
将邻接矩阵转化为边集数组:

void OperationEdge(Graph G, Edge* edges)
{
	int i, j,k;
	k = 0;
	//无向图对称,只需转换一半即可
	for (i = 0; i < G.numv; i++)
	{
		for (j = i+1; j < G.numv; j++)
		{
			if (G.edge[i][j] != INTMAX && G.edge[i][j] != 0)
			{
				edges[k].begin = i;
				edges[k].end = j;
				edges[k].weight = G.edge[i][j];
				k++;
			}
		}
	}
	//将weight从小到大交换排序
	Edge tmp;
	for (i = 0; i < k-1; i++)
	{
		for (j = i + 1; j < k; j++)
		{
			if (edges[i].weight > edges[j].weight)
			{
				tmp = edges[i];
				edges[i] = edges[j];
				edges[j] = tmp;
			}
		}
	}
}

克鲁斯卡尔算法:


void MinSpanTree_Kruskal(MGraph G)
{
	int i, n, m;
	Edge edges[MAXSIZE];  //定义边集数组
	int parent[MAXSIZE];  //用来判断边与边是否会成环
	OperationEdge(G, edges);
	for (i = 0; i < G.numv; i++)
	{
		parent[i] = 0;  //初始化数组值为 0
	}

	//循环每一条边
	for (i = 0; i < G.nume; i++)
	{
		n = Find(parent, edges[i].begin);
		m = Find(parent, edges[i].end);
		if (n != m)  //n!=m,说明没有成环,加入生成树
		{
			//将此边的结尾顶点放入下标为起点的parent中(n是起始顶点,m是结尾顶点)
			//n---m 这条边符合条件
			//表示该顶点已经在生成树集合中
			parent[n] = m;
			printf("(%d,%d),weight = %d", edges[i].begin,edges[i].end, edges[i].weight);
		}
	}
}

//查找连线顶点的尾部下标
int Find(int *parent,int f)
{
	while(parent[f] > 0)
	{
		f = parent[f]; 
	}
	return f;
}

对Find函数的理解:
整个算法执行的过程相当于是将多个树组成一个树,Find 函数中的 while 相当于是找到每棵小树的根结点,也就是说返回的 n 和 m 的值其实就相当于两棵小树的根节点,如果根结点相同,肯定就是同一棵树即图连通了;如果不相等,就将两棵小树连成一棵树即 parent[n] = m。若 while 没有找到根结点,即没有连通,那么这条边就重新建立一棵小树,并以一头为根即 f = parent[f]。
parent 数组中的 f 位置的值为0,其实也就是找到根结点了

对parent数组的理解:
parent[n] = m,就是说在 n 的位置上添加数值 m。
起初,parent 数组里面都为 0,进入Find函数都是直接返回。
parent[0] = 1,相当于下标为 0 的结点的根为1

二. 普利姆算法与克鲁斯卡尔算法的比较

1. 时间复杂度

普利姆算法: O(n²) ( n为顶点数 )

克鲁斯卡尔算法:O(eloge) (e为边数)

2.适应范围

普利姆算法:稠密图
克鲁斯卡尔算法:稀疏图

  • 16
    点赞
  • 54
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
以下是C语言实现的克鲁斯卡尔算法代码: ```c #include <stdio.h> #include <stdlib.h> #define MAX_EDGE 20 #define MAX_VERT 20 typedef struct edge { int u, v, weight; } edge; typedef struct graph { edge edges[MAX_EDGE]; int parent[MAX_VERT]; int n, e; } graph; void init_graph(graph *g) { g->n = 0; g->e = 0; } void add_edge(graph *g, int u, int v, int weight) { g->edges[g->e].u = u; g->edges[g->e].v = v; g->edges[g->e].weight = weight; g->e++; } int find_parent(int parent[], int i) { if (parent[i] == -1) { return i; } return find_parent(parent, parent[i]); } void union_set(int parent[], int x, int y) { int xset = find_parent(parent, x); int yset = find_parent(parent, y); parent[xset] = yset; } int compare_edges(const void *a, const void *b) { edge *a1 = (edge *) a; edge *b1 = (edge *) b; return a1->weight > b1->weight; } void kruskal(graph *g) { int i, j, x, y; int parent[MAX_VERT] = {-1,}; qsort(g->edges, g->e, sizeof(g->edges[0]), compare_edges); for (i = 0; i < g->e; i++) { x = find_parent(parent, g->edges[i].u); y = find_parent(parent, g->edges[i].v); if (x != y) { printf("%d - %d\n", g->edges[i].u, g->edges[i].v); union_set(parent, x, y); } } } int main() { graph g; init_graph(&g); add_edge(&g, 0, 1, 10); add_edge(&g, 0, 2, 6); add_edge(&g, 0, 3, 5); add_edge(&g, 1, 3, 15); add_edge(&g, 2, 3, 4); kruskal(&g); return 0; } ``` 这里实现了一个简单的图数据结构,包含了边和顶点数量,以及边的集合和父节点数组。kruskal函数是主要的算法实现,它根据边的权值排序,然后检查每条边是否会形成环路,如果不会,就加入最小生成树。在这个例子中,我们创建了一个简单的无向加权图,并使用克鲁斯卡尔算法计算最小生成树

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值