邻接表 prime算法_最小生成树 克鲁斯卡尔（Kruskal）算法

最新推荐文章于 2022-12-04 18:39:31 发布
最新推荐文章于 2022-12-04 18:39:31 发布
阅读量853 收藏
点赞数
文章标签： 邻接表 prime算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39681486/article/details/113365947
版权
本文详细介绍了克鲁斯卡尔（Kruskal）算法，用于找到无向图的最小生成树。该算法首先将边按权重排序，然后通过并查集数据结构判断添加边是否会形成环路，以避免环路的出现。在逐步添加边的过程中，确保了最小生成树的构建。文章包括算法要点、图解示例和代码实现。
摘要由CSDN通过智能技术生成

8a8d100c5968e71557a0972bfb5cc44b.png

克鲁斯卡尔（Kruskal）算法

克鲁斯卡尔（Kruskal）算法 是求最小生成树的 了解最小生成树

普利姆（Prime）算法是以 点 为基础，挑选与 已有点 相连的最小边。

克鲁斯卡尔（Kruskal）算法是以 边 为基础，先将边从小到大排列，从小到大的添加不构成「环路」的边。

判断「环路」使用的是 并查集 的数据结构 学习并查集

1.要点

  • 核心：先将边从小到大排列，从小到大的添加不构成「环路」的边
  • 判断「环路」：使用 并查集 的数据结构 学习并查集
  • 时间复杂度：O(n log n) （这是由排序方式实现的）

2.图解

求下面图的最小生成树

0266fd62ee3791a8375f157df8a80221.png

首先将边从小到大排列 如下表所示。

| 边 | from | to | weight | | ---------- | ---- | ---- | ------ | | edges[0] | B | C | 2 | | edges[1] | A | C | 3 | | edges[2] | A | B | 3 | | edges[3] | B | D | 4 | | edges[4] | C | D | 6 | | edges[5] | A | D | 7 |

选取最小的边 BC，

  1. 通过 并查集 find() 找到 root 根节点，判断 B、C 不为同一颗子树
  2. 通过 并查集 union() 将 B、C 合并为一颗树

324672c8172efc061045b875fe789b65.png

选取第二小的边 AC，

  1. 通过 并查集 find() 找到 root 根节点，判断 A、C 不为同一颗子树
  2. 通过 并查集 union() 将 A、{'B','C'} 合并为一颗树

5eb971241aa870951a5d14c7e944c825.png

选取第三小的边 AB，

  1. 通过 并查集 find() 找到 root 根节点，判断 A、B 为同一颗子树（被红色线连接的点）
  2. 不进行合并操作

选取第四小的边 BD，

  1. 通过 并查集 find() 找到 root 根节点，判断 B、D 不为同一颗子树
  2. 通过 并查集 union() 将 D、{'A',B','C'} 合并为一颗树

65cc721464dac4bd543e9e33d6c86edd.png

我们得到了这个无向图的 最小生成树 （如上图所示）

3.代码

public ArrayList<Integer> kruskal(){
  //已经连接的点
  ArrayList<Integer> connectedVertices = new ArrayList<>();
  //获取图中的所有的边
  List<Edge> edges = getAllEdges();
  //将所有的边进行排序
  sortEdges(edges);
  //这里使用并查集寻找出最小生成树
  for (int i = 0; i < edges.size(); i++) {
    int fromVertexIndex = edges.get(i).from;
    int toVertexIndex = edges.get(i).to;
    boolean sameTree = find(fromVertexIndex) == find(toVertexIndex);
    //如果不是同一个树
    if (sameTree == false){
      System.out.println(vertices[fromVertexIndex] + " --> " + vertices[toVertexIndex] + " weight:" +graph[fromVertexIndex][toVertexIndex]);
      //合并为同一个树
      union(find(fromVertexIndex),find(toVertexIndex));
      //包含 to 点就添加 from 点
      if (connectedVertices.contains(toVertexIndex)) {
        connectedVertices.add(fromVertexIndex);
      }
      //包含 from 点 就添加 to 点
      else if (connectedVertices.contains(fromVertexIndex)){
        connectedVertices.add(toVertexIndex);
      }
      // 2 个都不包含就都添加
      else {
        connectedVertices.add(fromVertexIndex);
        connectedVertices.add(toVertexIndex);
      }
    }
    //如果全部点都已经连接就退出循环
    if (connectedVertices.size() == vertices.length){
      break;
    }
  }
  return connectedVertices;
}
例如 getAllEdges() 、 sortEdges()、 find()、 union() 个方法上面就不赘述了，你可以 点击连接查看完整 Kruskal 代码

测试效果

B --> C weight:2
A --> C weight:3
B --> D weight:4克鲁斯卡尔（Kruskal）算法
普利姆（Prime）算法，克鲁斯卡尔（Kruskal）算法 是求最小生成树的，阅读之前请先了解
了解最小生成树
了解并查集

普利姆（Prime）算法 是以 点 为基础，挑选与 已有点 相连的最小边。

克鲁斯卡尔（Kruskal）算法是以 边 为基础，先将边从小到大排列，从小到大的添加不构成「环路」的边。

判断「环路」使用的是 并查集 的数据结构

1.要点

  • 核心：先将边从小到大排列，从小到大的添加不构成「环路」的边
  • 判断「环路」：使用 并查集 的数据结构
  • 时间复杂度：O(n logn) （这是由排序方式实现的）

2.图解

求下面图的最小生成树

0266fd62ee3791a8375f157df8a80221.png

首先将边从小到大排列 如下表所示。

310f287ad55b404ba48d5857a00e8722.png

选取最小的边 BC，

  1. 通过 并查集 find() 找到 root 根节点，判断 B、C 不为同一颗子树
  2. 通过 并查集 union() 将 B、C 合并为一颗树

324672c8172efc061045b875fe789b65.png

选取第二小的边 AC，

  1. 通过 并查集 find() 找到 root 根节点，判断 A、C 不为同一颗子树
  2. 通过 并查集 union() 将 A、{'B','C'} 合并为一颗树

5eb971241aa870951a5d14c7e944c825.png

选取第三小的边 AB，

  1. 通过 并查集 find() 找到 root 根节点，判断 A、B 为同一颗子树（被红色线连接的点）
  2. 不进行合并操作

选取第四小的边 BD，

  1. 通过 并查集 find() 找到 root 根节点，判断 B、D 不为同一颗子树
  2. 通过 并查集 union() 将 D、{'A',B','C'} 合并为一颗树

65cc721464dac4bd543e9e33d6c86edd.png

我们得到了这个无向图的 最小生成树 （如上图所示）

3.代码

/** 顶点 */
private static Character[] vertices;
/** Graph 邻接矩阵 */
private static int[][] graph;
/** 定义最大值 */
private static final int MAX = Integer.MAX_VALUE;
//初始化数据
static{
  vertices = new Character[]{'A', 'B', 'C', 'D'};
  graph = new int[][]{
    {0,3,3,7}
    ,{3,0,2,4}
    ,{3,2,0,6}
    ,{7,4,6,0}};
};
/** 定义边 Edge */
class Edge  implements Comparator<Edge> {
  int from;
  int to;
  int weight;
  public Edge(int from, int to, int weight) {
    this.from = from;
    this.to = to;
    this.weight = weight;
  }
}
/** kruskal */
public ArrayList<Integer> kruskal(){
  //已经连接的点
  ArrayList<Integer> connectedVertices = new ArrayList<>();
  //获取图中的所有的边
  List<Edge> edges = getAllEdges();
  //将所有的边进行排序
  sortEdges(edges);
  //这里使用并查集寻找出最小生成树
  for (int i = 0; i < edges.size(); i++) {
    int fromVertexIndex = edges.get(i).from;
    int toVertexIndex = edges.get(i).to;
    boolean sameTree = find(fromVertexIndex) == find(toVertexIndex);
    //如果不是同一个树
    if (sameTree == false){
      System.out.println(vertices[fromVertexIndex] + " --> " + vertices[toVertexIndex] + " weight:" +graph[fromVertexIndex][toVertexIndex]);
      //合并为同一个树
      union(find(fromVertexIndex),find(toVertexIndex));
      //包含 to 点就添加 from 点
      if (connectedVertices.contains(toVertexIndex)) {
        connectedVertices.add(fromVertexIndex);
      }
      //包含 from 点 就添加 to 点
      else if (connectedVertices.contains(fromVertexIndex)){
        connectedVertices.add(toVertexIndex);
      }
      // 2 个都不包含就都添加
      else {
        connectedVertices.add(fromVertexIndex);
        connectedVertices.add(toVertexIndex);
      }
    }
    //如果全部点都已经连接就退出循环
    if (connectedVertices.size() == vertices.length){
      break;
    }
  }
  return connectedVertices;
}
getAllEdges() 、 sortEdges()、 find()、 union() 个方法上面就不赘述了，你可以
点击连接查看完整Kruskal代码

测试效果

B --> C weight:2
A --> C weight:3
B --> D weight:4
总结：
Kruskal算法先将所有的边进行排序
然后依次添加边上的节点（但是不能形成「环路」）
判断是否为「环路」使用的是 并查集 的数据结构
拓展
克鲁斯卡尔（Kruskal）算法属于贪心算法的一种（贪心算法还有 Kruskal克鲁斯克拉算法、Dijkstra迪克斯特拉算法、哈夫曼树、编码算法等）
weixin_39681486
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
度限制最小生成树和第K最短路算法
程序猿老樊的博客
01-14 1036
最小生成树算法和第K最短路算法都是图论中的经典算法，它们在网络设计、路由选择等多个领域有着重要应用。这些算法在实际应用中通常需要根据具体问题的特点来选择合适的算法。MST算法着重于构造最小权重的树，而第K最短路算法侧重于寻找多条不同的路径。
最小生成树(C语言简单实现)
DFGOMC的博客
11-17 7876
最小生成树 本文参考自《大话数据结构》 一个连通图的生成树是一个极小的连通子图，它含有图中全部的顶点，但只有足以构成一棵树的n-1条边。我们把构造连通网的最小代价生成树称为最小生成树 。 找连通网的最小生成树，经典的有两种算法：普里姆算法和克鲁斯卡尔算法。 普里姆(Prim)算法 /* Prim算法生成最小生成树 */ void MiniSpanTree_Prim(MGraph G){ int min, i, j, k; int adjvex[MAXVEX]; //保存相关顶点下标 int low
C语言邻接表结构实现克鲁斯卡尔算法
12-27
C语言采用邻接表结构实现克鲁斯卡尔算法。 也可以在相应github上下载，https://github.com/Sunnk/Data-Structure，其中Kruskal文件夹中即为克鲁斯卡尔算法，可用vs打开
C++：用邻接表表示克鲁斯卡尔算法
m0_62518283的博客
04-13 1044
typedef struct ArcNode { char adjvex; ArcNode* nextArc; int weight; }ArcNode,*pArcNode; typedef struct VNode { char date; pArcNode firstArc; }VNode,*pVNode; typedef struct { pVNode vert; int vexnum, arcnum; }ALGraph; typedef struct Ed{ char Hea.
最小生成树，克鲁斯卡尔（Kruskal）算法，邻接表
weixin_44350170的博客
07-26 1496
基本思想：将所有顶点之间路径权值，从小到大有序排列，并在程序中优先遍历路径小的顶点，记录不存在环的路径，直至全部循环完毕。 There are N villages, which are numbered from 1 to N, and you should build some roads such that every two villages can connect to each oth...
Kruskal算法C语言实现
The Blog Of Tianalangz
12-24 3935
#include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <string.h>#define MAX 100 // 矩阵最大容量 #define INF (~(0x1<<31)) // 最大值(即0X7FFFFFFF) #define isLet
【图】图的遍历以及最小生成树
菜鸟成长记
07-31 2976
图的遍历图的遍历图和树的遍历类似，那就是从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这个过程就叫做图的遍历。对于图的遍历来说，如何避免因回路陷入死循环，就需要科学地设计遍历方案，通过有两种遍历次序方案：深度优先遍历和广度优先遍历。1、深度优先遍历 DFS深度优先遍历（Depth_First_Search）,也称为深度优先搜索，简称DFS。沿着树的深度遍历树的节点，尽可能深的搜索树
数据结构之最小生成树
u013071074的专栏
06-09 2681
最小生成树： 一个连通图的生成树是一个极小连通子图，它含有图中全部顶点，但只有足以构成一棵树的n-1条边。这种构造连通网的最小代价生成树称为最小生成树，详见数据结构之图（术语、存储结构、遍历）。 求连通网的最小生成树有两种经典方法：普里姆（Prime）算法和克鲁斯卡尔（Kruskal）算法。 1、Prime算法 (1)算法描述 假设N=(V,{E})是连通网，TE是N上最小生成树中边的集合。从V中任选一个顶点u0，算法从U={u0}(u0∈V)，TE={}开始，重复执行以下步骤： 在所有u∈U、v∈V-
Prim算法
WANGHAOXIN364的博客
07-28 1248
Prim算法
邻接表实现无向图的建立与遍历，最小生成树以及最短路径
10-20
使用邻接表来实现无向图的建立与遍历，同时给出prim算法求最小生成树以及krustra算法求最短路径.代码中给出了注释方便理解
最小生成树（邻接表写法）
saplingyang的博客
03-02 3202
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define max 20 typedef struct ArcNode { int adjvex; struct ArcNode *nextarc; int info; } ArcNode; typedef struct VertexNode { char data; ArcNode ...
图之Prime算法(邻接表)实现----最小生成树
杨龙飞的博客
12-09 3400
1.prime算法思想:(只与顶点有关)prime算法求最小生成树时，和边数无关，只和顶点的数量有关，时间复杂度是O(n^2),所以呢，适合于求稠密网的最小生成树;将一个图的顶点分为两部分,一部分是最小生成树的集合，这里就记为(A集合),另一部分是未处理的顶点集合. 首先，选择一个节点，将这个节点加入A集合，然后，对集合A中的顶点遍历,找出A中顶点关联的边权值最小的点加入A集合。 不断重复第二步，直
kruskal算法 求最小生成树（邻接表 无向图) C实现
Unyielding will
08-11 2989
kruskal 路径压缩 按秩归并
最小生成树 --------克鲁斯卡尔（kruskal）算法+邻接矩阵
玩转Java
03-20 3234
最小生成树 --------克鲁斯卡尔（kruskal）算法+邻接矩阵: 这里采用邻接矩阵的存储方式，其中用到了直接插入排序，对边权值进行排序，另外，这里定义的e[]数组是存储每条边的相关信息（边的两端点+权值） 算法思想就是找边小的边，将边两端点加入构造结合内，循环找（因为是排好序的），循环从小到大就可以了，遇到连通值相同的顶点，如果他们之间有边值，需要舍弃掉，因为加入到构造集合内会形成回路，我们这里要找的是不能形成回路的。 代码如下： #include <stdio.h> #include
数据结构：Prim算法--最小生成树(邻接链表)
最新发布
m0_67695275的博客
12-04 975
Prim求最小生成树，邻接链表储存图
Prime算法求最小生成树 (邻接表）
QiaoRuoZhuo的专栏
11-26 2310
实现了 Prime算法求最小生成树 (邻接表）的普通算法和最小堆优化算法。
C语言邻接表——最小生成树——prim+kruskal
qq_18824403的博客
04-23 4887
1.Prim实现 #include<stdio.h> #include<stdlib.h> #define MaxVertices 100 #define INF 65535 int graph[MaxVertices][MaxVertices]; typedef char DataType; //建立边表 typedef struct node { int adjvex...
数据结构学习笔记（四） 图之邻接表实现最小生成树prim算法
Clementina_123的博客
01-30 3617
以下是使用邻接表存储表示的，最小生成树prim算法的应用实例。 用于演示的图如下： #include<iostream> #define MaxVertexNum 6 #define MAXNUM 65535 using namespace std; //抽象数据类型 typedef char vertextype;//顶点类型 //边结点类型 typedef struct edge {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值