最小生成树之普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法

最新推荐文章于 2024-05-22 11:57:45 发布
最新推荐文章于 2024-05-22 11:57:45 发布
阅读量2w 收藏 372
点赞数 73
分类专栏： 数据结构 文章标签： 最小生成树 普里姆算法 克鲁斯卡尔算法

作者：STzen
链接：https://www.jianshu.com/p/683ffde4f3a3
来源：简书

最小生成树

列子引入

在这里插入图片描述
如图假设v0到v8表示9个村庄，现在需要在这9个村庄假设通信网络。村庄之间的数字代表村庄之间的直线距离，求用最小成本完成这9个村庄的通信网络建设。

分析

这幅图是一个带权值的图，即网结构。
所谓最小成本，就是n个顶点，用n-1条边把一个连通图连接起来，并且使权值的和最小。

最小生成树

如果无向连通图是一个网图，那么它的所有生成树中必有一颗是边的权值总和最小的生成树，即最小生成树。
找到连通图的最小生成树，有两种经典的算法：普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法

一、普里姆(Prim)算法

在这里插入图片描述

普利姆算法步骤

从图中某一个顶点出发(这里选V0)，寻找它相连的所有结点，比较这些结点的权值大小，然后连接权值最小的那个结点。（这里是V1）
然后将寻找这两个结点相连的所有结点，找到权值最小的连接。（这里是V5）.
重复上一步，知道所有结点都连接上。
在这里插入图片描述

实现代码

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

#define MAXEDGE 20
#define MAXVEX 20
#define INIFINTY 65535

typedef struct {
    
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
    
}MGraph;

/**
 * 构建图
 */
void CreateMGraph(MGraph * G){
    
    int i, j;
    
    G->numVertexes = 9;  // 9个顶点
    G->numEdges = 15;  // 15条边
    
    for (i = 0; i < G->numVertexes; i++) {  // 初始化图
        for (j = 0; j < G->numVertexes; j++) {
            if (i == j)
                G->arc[i][j] = 0;
            else
                G->arc[i][j] = G->arc[j][i] = INIFINTY;
        }
    }
    
    G->arc[0][1] = 10;
    G->arc[0][5] = 11;
    
    G->arc[1][2] = 18;
    G->arc[1][8] = 12;
    G->arc[1][6] = 16;
    
    G->arc[2][3] = 22;
    G->arc[2][8] = 8;
    
    G->arc[3][4] = 20;
    G->arc[3][7] = 16;
    G->arc[3][6] = 24;
    G->arc[3][8] = 21;
    
    G->arc[4][5] = 26;
    G->arc[4][7] = 7;
    
    G->arc[5][6] = 17;
    
    G->arc[6][7] = 19;
    
    // 利用邻接矩阵的对称性
    for (i = 0; i < G->numVertexes; i++)
        for (j = 0; j < G->numVertexes; j++)
            G->arc[j][i] = G->arc[i][j];
}


/**
 * Prime算法生成最小生成树
 */
void MiniSpanTree_Prim(MGraph G){
    
    int min,i,j,k;
    
    int adjvex[MAXVEX]; // 保存相关顶点的下标
    int lowcost[MAXVEX]; // 保存相关顶点间边的权值
    
    lowcost[0] = 0;  // 初始化第一个权值为0，即v0加入生成树
    adjvex[0] = 0; // 初始化第一个顶点下标为0
    
    for (i = 1; i < G.numVertexes; i++) {  // 循环除下标为0外的全部顶点
        lowcost[i] = G.arc[0][i];  // 将v0顶点与之右边的权值存入数组
        adjvex[i] = 0; // 初始化都为v0的下标
    }
    
    for (i = 1; i < G.numVertexes; i++) {
        
        min = INIFINTY; //初始化最小权值
        j = 1;
        k = 0;
        
        while (j < G.numVertexes) { // 循环全部顶点
            if (lowcost[j] != 0 && lowcost[j] < min) {
                min = lowcost[j];  // 让当前权值变为最小值
                k = j;  // 将当前最小值的下标存入k
            }
            j++;
        }
        
        printf("(%d, %d)\n", adjvex[k], k);  // 打印当前顶点中权值最小的边
        lowcost[k] = 0;             // 将当前顶点的权值设置为0，表示此顶点已经完成任务
        
        for (j = 1; j < G.numVertexes; j++) {  // 循环所有顶点
            if (lowcost[j]!= 0 && G.arc[k][j] < lowcost[j]) {  // 如果下标为k顶点各边权值小于当前这些顶点未被加入生成树权值
                lowcost[j] = G.arc[k][j]; // 将较小的权值存入lowcost相应的位置
                adjvex[j] = k;   // 将下标为k的顶点存入adjvex
            }
        }
    }
}

int main(int argc, const char * argv[]) {
    
    MGraph G;
    CreateMGraph(&G);
    MiniSpanTree_Prim(G);
    
    return 0;
}

代码解释

  • 创建了两个数组adjvex和lowcost。adjvex[0] = 0意思就是从V0开始，lowcost[0] =
    0表示V0已经被纳入到最小生成树中。之后凡是lowcost数组中的值被设置为0就是表示此下标的顶点被纳入最小生成树。
  • 普里姆算法的时间复杂度为O(n^2)，因为是两层循环嵌套。

代码运行结果

在这里插入图片描述

二、克鲁斯卡尔(Kruskal)算法

普里姆算法是从某一顶点为起点，逐步找各个顶点最小权值的边来构成最小生成树。那我们也可以直接从边出发，寻找权值最小的边来构建最小生成树。不过在构建的过程中要考虑是否会形成环的情况

边集数组存储图

在这里插入图片描述
在直接用边来构建最小生成树的时候，需要用到边集数组结构，代码为：

typedef struct {  // 边集数组
    int begin;
    int end;
    int weight;
}Edge;

代码实现

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

#define MAXEDGE 20
#define MAXVEX 20
#define INIFINTY 65535

typedef struct {
    
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
    
}MGraph;

typedef struct {  // 边集数组
    int begin;
    int end;
    int weight;
}Edge;

/**
 * 构建图
 */
void CreateMGraph(MGraph * G){
    
    int i, j;
    
    G->numVertexes = 9;  // 9个顶点
    G->numEdges = 15;  // 15条边
    
    for (i = 0; i < G->numVertexes; i++) {  // 初始化图
        for (j = 0; j < G->numVertexes; j++) {
            if (i == j)
                G->arc[i][j] = 0;
            else
                G->arc[i][j] = G->arc[j][i] = INIFINTY;
        }
    }
    
    G->arc[0][1] = 10;
    G->arc[0][5] = 11;
    
    G->arc[1][2] = 18;
    G->arc[1][8] = 12;
    G->arc[1][6] = 16;
    
    G->arc[2][3] = 22;
    G->arc[2][8] = 8;
    
    G->arc[3][4] = 20;
    G->arc[3][7] = 16;
    G->arc[3][6] = 24;
    G->arc[3][8] = 21;
    
    G->arc[4][5] = 26;
    G->arc[4][7] = 7;
    
    G->arc[5][6] = 17;
    
    G->arc[6][7] = 19;
    
    // 利用邻接矩阵的对称性
    for (i = 0; i < G->numVertexes; i++)
        for (j = 0; j < G->numVertexes; j++)
            G->arc[j][i] = G->arc[i][j];
}


/**
 * 交换权值、头、尾
 */
void Swapn(Edge * edges, int i, int j){
    
    int temp;
    temp = edges[i].begin;
    edges[i].begin = edges[j].begin;
    edges[j].begin = temp;
    
    temp = edges[i].end;
    edges[i].end = edges[j].end;
    edges[j].end = temp;
    
    temp = edges[i].weight;
    edges[i].weight = edges[j].weight;
    edges[j].weight = temp;
}

/**
 * 对权值进行排序
 */
void sort(Edge edges[], MGraph *G){

    int i,j;
    
    for (i = 0;  i < G->numEdges; i++) {
        for (j = i+1; j < G->numEdges; j++) {
            if (edges[i].weight > edges[j].weight)
                Swapn(edges, i, j);
        }
    }
    
    printf("权值排序之后为：\n");
    
    for (i = 0;  i < G->numEdges; i++) {
        printf("(%d, %d) %d\n", edges[i].begin, edges[i].end, edges[i].weight);
    }
}

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


void MiniSpanTree_Kruskal(MGraph G){
    
    int i,j,n,m;
    
    int k = 0;
    
    Edge edges[MAXEDGE]; // 定义边集数组
    int parent[MAXVEX]; // 定义一维数组来判断边与边是否形成回路
    
    //构建边集数组并排序
    for (i = 0; i < G.numVertexes - 1; i++) {
        for (j = i+1; j < G.numVertexes; j++) {
            if (G.arc[i][j] < INIFINTY) {
                edges[k].begin = i;
                edges[k].end = j;
                edges[k].weight = G.arc[i][j];
                k++;
            }
        }
    }
    sort(edges, &G);
    
    
    for (i = 0; i < G.numVertexes; i++) {
        parent[i] = 0;
    }
    
    printf("打印最小生成树:\n");
    for (i = 0;  i < G.numEdges; i++) {
        n = Find(parent, edges[i].begin);
        m = Find(parent, edges[i].end);
        
        if (n != m) {
            parent[n] = m;
            printf("(%d, %d) %d\n",edges[i].begin, edges[i].end
                   , edges[i].weight);
        }
    }
}

int main(int argc, const char * argv[]) {
    
    MGraph G;
    CreateMGraph(&G);
    MiniSpanTree_Kruskal(G);
    
    return 0;
}

代码解释

  • 先构建边集数组，并排序，所以前面有对权值进行排序的方法sort。
  • 克鲁斯卡尔(Kruskal)算法的时间复杂度为O(eloge)。

运行结果

在这里插入图片描述

对比普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法

  • 克鲁斯卡尔(Kruskal)算法主要针对边来展开，边数较少时效率非常高，所以对于稀疏图有很大的优势；
  • 普里姆(Prim)算法对于稠密图，边数非常多的情况更好一些。
iKendall
关注
  • 73
    点赞
  • 踩
  • 372
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
最小生成树(prime和Kruskal算法)
king1747175426的博客
11-26 1643
最小生成树 https://blog.csdn.net/qq_43811879/article/details/103131464?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160638375319195271661654%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=160638375319195271661654&biz
C++实现最小生成树之普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法
08-07
1、最小生成树的概念； 2、Prim算法及其实现； 3、Kruskal算法及其实现； 4、图的表示； 5、边的表示； 6、优先队列priority_queue的自定义排序 7、大根堆、小根堆的区别 8、结构体的构建 面向对象： 有一定C++基础...
最小生成树之克鲁斯卡尔算法和普里姆算法
热门推荐
青萍之末的博客
06-04 3万+
一、最小生成树简介   假设有一个很实际的问题：我们要在n个城市中建立一个通信网络，则连通这n个城市需要布置n-1一条通信线路，这个时候我们需要考虑如何在成本最低的情况下建立这个通信网？   于是我们就可以引入连通图来解决我们遇到的问题，n个城市就是图上的n个顶点，然后，边表示两个城市的通信线路，每条边上的权重就是我们搭建这条线路所需要的成本，所以现在我们有n个顶点的连通网可以建立不同的生成...
最小生成树—Kruskal算法和Prim算法
终为nullptr
05-20 1643
求图的最小生成树的两种算法Kruskal算法和Prim算法解析
克鲁斯卡尔和普里姆算法（最小生成树的构造过程详解）（期末考试速成大法）
最新发布
qq_37040743的博客
05-22 582
普里姆算法就是，（如果有多个最短边，那就随便选一个）如图所示，。第二步，在未选取的点中，选取一个与已选取点最近的点连上。听不懂？一眼看出是4注结果就是将4这条边加入：继续选最小的边，一眼是值为2的这条边结果：此时发现有其中如果选取了就形成了一个环，不满足最小生成树的定义，我们就去除（注：每次选取边后，如果形成了一个闭合的环就要舍弃边）那么我们只能选剩下来的那条边了结果就是：继续选取边（形成闭环的边不选取）那只剩下3,6,6了，一眼3最终结果：当所有点都被连起来后就结束了，
prim算法和kruskal算法详解
陌意随影的博客
10-22 1934
在我们的数据结构中，当涉及到图的寻找最小的路径时，不得不提到最经典的寻找图的最小生成树的算法： prim算法和kruskal算法详解。下面笔者将与大家共同探讨一下这两个经典的算法和他们的C++代码实现。 首先我们先看引自百度百科的prim算法的定义：普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英...
Prim算法
10247D的博客
01-11 2229
图的概念与性质为了保证学习效果，请保证已经掌握前置知识之后，再来学习本章节！如果在阅读中遇到困难，也可以回到前面章节查阅。
数据结构与算法－最小生成树之克鲁斯卡尔（Kruskal)算法
越陌度阡
06-05 1265
算法步骤 1. 设G = ( V,E )，令最小生成树初始状态为只有n个顶点而无边的非联通图 T=( V，{ } )，每个顶点自成一个连通分量； 2. 在E中选取权值最小的边，若该边依附的顶点落在T中不同的连通分量上，且不构成回路，则将此边加入到T 中，否则，舍去此边，选取下一条权值最小的边； 3. 以此类推，重复第2步，直至T中所有顶点都在同一连通分量上为止。 算法实例 假设现在我们已经通过邻接矩阵得到了边集数组并按权值从小到大排列如下图。 未完待续。。。 ......
python最小生成树kruskal与prim算法详解
09-19
主要为大家详细介绍了python最小生成树kruskal与prim算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
头歌数据结构图的最小生成树算法
05-26
头歌数据结构图的最小生成树算法 第1关求图（邻接矩阵存储）最小生成树的普里姆（Prim）...构造最小生成树的方法有许多种，典型的构造方法有两种，一种称作普里姆（Prim）算法，另一种称作克鲁斯卡尔（Kruskal）算法。
最小生成树算法（Prim Kruskal）
11-21
主要有两种著名的算法：普里姆（Prim）算法和克鲁斯卡尔（Kruskal）算法。 **普里姆算法**： 普里姆算法是一种贪心策略，它从一个起始顶点开始，逐步增加边来扩展生成树，每次都选择与当前生成树连接的边中权重...
贪心算法Dijkstra普里姆(Prim)克鲁斯卡尔算法,最短路算法.docx
04-13
在本实验中，主要涉及了三种贪心算法的应用：Dijkstra算法、Prim算法和Kruskal算法，它们主要用于解决图论中的最短路径和最小生成树问题。 1. Dijkstra算法：Dijkstra算法是用于寻找有向图或无向图中源节点到其他...
Kruskal算法
Thewei666的博客
03-04 754
主要由排序方法决定，而它的排序方法只与图中边的条数有关，而与图中顶点的个数无关，当使用时间复杂度为O（elog2e）的排序方法时，Kruskal算法的时间复杂度即为O（log2e）是求连通网的最小生成树的另一种方法。与Prim算法不同，它的时间复杂度为O（eloge）（e为图中的边数），所以，适合于求边稀疏的网的最小生成树。：图的顶点个数较多、而边的条数较少时，使用Kruskal算法构造最小生成树效果较好。
Acwing 858-Prim算法求最小生成树
她与伞皆过客的博客
04-29 1282
给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。 求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。 给定一张边带权的无向图G=(V,E)，其中VV表示图中点的集合，EE表示图中边的集合，n=|V|，m=|E|。 由V中的全部n个顶点和E中n−1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。 输入格式 第一行包含两个整数n和m。 接下来m行，每...
最小生成树——Prim算法和Kruskal算法详解
mustach的博客
05-11 3736
最小生成树 对于一个带权连通无向图G=（V，E），生成树不同，每棵树的权（即树中所有边上的权值之和）也可能不同，设r为G的所有生成树的集合，若T为r中边的权值之和最小的那棵生成树，则T称为G的最小生成树。 最小生成树的性质： 最小生成树不是唯一的。 最小生成树的边的权值之和总是唯一的 最小生成树的边数为顶点数减1，即边数=n-1（n为顶点数） 下面介绍两种实现最小生成树的算法： 普里姆（Prim）算法 Prim算法的执行非常类似于寻找图的最短路径的Dijkstra算法。 基...
常用十大算法_普里姆（prim）算法，克鲁斯卡尔（Kruskal）算法
泥煤少年的博客
07-25 1425
求最小生成树MST：Prim算法（普里姆算法） 最小生成树简称为MST，给定一个带权的无向连通图，如何选取一棵生成树，使树上所有边上权的总和为最小，这叫最小生成树。 上图中红框标记的子图就是我们要的最小生成树 引入MST概念后，我们以经典的修路问题来引出prim算法 【例子】如下图，有一个7村庄（A~G），需要修路将7个村庄连通，且不同路的路径不同（权值不同），要求既要连通7村，也要路径最短 算法分析： 就是一个求MST的题，接下来我们用prim算法求MST prim算法核心就是：.
快速排序算法的时间复杂度分析[详解Master method]
weixin_34144450的博客
07-02 974
  快速排序算法的时间复杂度分析[详解Master method]   经常听人谈起各种排序算法的时间复杂度，这个是O(n2)的，那个是O(n)的，这些人讲起来可谓滔滔不绝，但是你停下来问问他为什么这个是这个复杂度，他是怎么算出来的？往往没几个人能说出来。这个是一个浮躁的社会，大家都追求速度，到处复制，粘贴代码，拿人家的代码跑一便，就说自己会了这个，会了那个..   也许有人觉得算法分析...
大话数据结构——最小生成树~Prim算法~O(n^2)~2020.7.15
fatfairyyy的博客
07-15 274
Prim算法，时间复杂度O(n ^ 2)，用于生成最小生成树。以下直接放出代码，注释中详细解释了代码的思想及需要注意的地方。 #include <iostream> #include <cstring> #include <cstdio> #define MAXVEX 105 #define INFINITY 65535 using namespace std; typedef char VertexType;//顶点类型 typedef int EdgeType;//
最小生成树 kruskal算法+时间复杂度
8rfuz的博客
10-08 2万+
Kruskal算法与Prime算法的区别就在于一个是以边为目标进行考虑，一个以点为目标进行考虑。 由于Kruskal算法以边进行考虑，就涉及到边可能属于两个连通块，这时候就涉及到连通块的判断查找合并。 这个知识点属于 算法导论里  不相交集合 的 内容。
最小生成树的普里姆算法和克鲁斯卡尔算法c语言
12-12
以下是最小生成树的普里姆算法和克鲁斯卡尔算法的C语言实现： 1. 普里姆算法 ```c #include #include #define V 5 int minKey(int key[], bool mstSet[]) { int min = INT_MAX, min_index; for (int v = 0;...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值