算法：以不相交集类(DisjointSet)作为辅助工具类，用Java实现克鲁斯卡尔(Kruskal)算法求出图的最小生成树

最新推荐文章于 2021-12-22 22:01:54 发布
最新推荐文章于 2021-12-22 22:01:54 发布
阅读量285 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39448458/article/details/103123188
版权

之前我用克鲁斯卡尔(Kruskal)算法求出了图的最小生成树（还记得是如何求出最小生成树的吗？就是把图的所有边拿出来，按权重从小到大排列，依次拿边尝试放到图中。如果边放进去不形成环，则放进去。如果边放进去会形成环，则这条边舍弃，然后继续尝试下一条边，直到图中所有点连通，共需要图顶点数-1条边），因为当时还不知道不相交集类这么个数据结构与算法，所以在判断一条边是接受还是舍弃的时候，用的邻接矩阵的的广度优先遍历算法(BFS)来判断两个顶点是否是连通的（点我查看）。现在有了不相交集类这么个利器，实现克鲁斯卡尔(Kruskal)算法就更加方便了。

我们在往图中一条一条添加边的过程中，刚开始可以看做所有的顶点都是不等价的。然后加入一条边，也就是将该边的两个顶点合并，然后这两个顶点就等价了，也就是连通了。每次加入边之前需要判断该边的两个顶点是否等价，也就是是否连通。如果等价，则代表两个顶点已经连通了，该边需要舍弃，否则就有环了。如果不等价，则代表两个顶点不连通，则接受该边，然后再将该边的两个顶点求并。直到接受的边等于顶点数-1，或者所有的边都已经经过以上算法的计算，算法结束，所有组成图的最小生成树的边已全部得到。

我们再梳理一下不相交集类和图的对应关系：

  1. 图的所有顶点，就对应不相交集类的所有元素
  2. 如果图的两个顶点连通，就对应不相交集类的两个元素的等价
  3. 如果图的两个顶点不连通，也就对应不相交集类的两个元素不等价
  4. 在求最小生成树的过程中，两个顶点判定为不连通（不等价），然后加入这条边，就对应不相交集类的两个元素的求并操作
  5. 最后用克鲁斯卡尔(Kruskal)算法求出了最小生成树，图的意义就是所有顶点均连通了，不相交集类的意义就是所有元素都等价了
  6. 所以，图的顶点的连通关系，就一一对应不相交集类的等价关系。合并操作就是加边，加边就是对应合并。当然，如果已经生成最小生成树，还继续加边，则对应合并操作（虽然此后的加边对应的合并，两个顶点的根顶点相同，不进行合并操作）依然有效。也就是说，无论加多少边，不相交集类依然可以通过等价关系，判定两个顶点是否连通。甚至可以通过之前对不相交集类的统计方法（点 这里 查看博文的arrangeDisjointSet()方法），求出哪些顶点是连通的，最后得到整个图的所有顶点的连通关系

我们还是拿那个示例图来举例子，我们要求下面这张图的最小生成树：
在这里插入图片描述
下面的这张图，就是上面示例图的最小生成树：
在这里插入图片描述
根据示例图的最小生成树，我们可以得到，V1-V7这七个顶点已经连通，但是连通他们的边的权重和是最小的。你找不到更小的连通图，连通边的权重和比上面的图还要小了。连通他们的最小生成树的组成边为：

  1. V1 - V4，权重为1
  2. V6 - V7，权重为1
  3. V1 - V2，权重为2
  4. V3 - V4，权重为2
  5. V4 - V7，权重为4
  6. V5 - V7，权重为6

从上面的答案，我们也可以看出，最小生成树组成的边的数量，就是顶点数-1，也验证了之前的定理。如何用不相交集类作为辅助工具类，用克鲁斯卡尔(Kruskal)算法求出上面示例图的最小生成树呢？实现的代码如下，算法的思想和精髓都在代码和其间的详细注释中：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author LiYang
 * @ClassName KruskalByDisjointSet
 * @Description 用不相交集类(DisjointSet)，实现克鲁斯卡尔(Kruskal)算法
 * @date 2019/11/18 14:20
 */
public class KruskalByDisjointSet {

    /**
     * 图的边类
     * 刚开始需要将所有的边按权重，从小到大排列，
     * 然后依次尝试加入到图中，直到生成最小生成树
     */
    static class Edge implements Comparable<Edge> {
        
        //顶点1的下标(到时候对应String[] vertexName)
        private int vertex1;
        
        //顶点2的下标(到时候对应String[] vertexName)
        private int vertex2;
        
        //边的权重
        private int weight;

        /**
         * 全参数的构造方法
         * @param vertex1 顶点1的下标
         * @param vertex2 顶点2的下标
         * @param weight 边的权重
         */
        public Edge(int vertex1, int vertex2, int weight) {
            this.vertex1 = vertex1;
            this.vertex2 = vertex2;
            this.weight = weight;
        }
        
        public int getVertex1() {
            return vertex1;
        }

        public int getVertex2() {
            return vertex2;
        }

        public int getWeight() {
            return weight;
        }

        /**
         * 重写compareTo方法，按边的权重从小到大排序
         * @param o
         * @return
         */
        @Override
        public int compareTo(Edge o) {
            return this.weight - o.weight;
        }
    }

    /**
     * 不相交集工具类，按高度来合并
     * 实现代码根之前的不相交集类一样
     * 这里作为内部类，辅助实现Kruskal算法
     */
    static class DisjointSetUnionByHeight {
        //不相交集类(并查集)的顶点数组
        private int[] vertexes;

        /**
         * 不相交集类(并查集)的构造方法，入参顶点个数
         * @param vertexNum 顶点个数
         */
        public DisjointSetUnionByHeight(int vertexNum) {
            if (vertexNum <= 0) {
                throw new IllegalArgumentException("顶点个数要大于零");
            }

            //实例化不相交集类(并查集)的顶点数组
            this.vertexes = new int[vertexNum];

            //初始化顶点树的高度都为-1(如果是根，值就是负数，连通顶点组成的树
            //的高度是多少，则根元素就是负几)
            for (int i = 0; i < vertexes.length; i++) {
                this.vertexes[i] = -1;
            }
        }

        /**
         * 查询不相交集类(并查集)的顶点个数
         * @return 顶点个数
         */
        public int size() {
            return vertexes.length;
        }

        /**
         * 查询不相交集类(并查集)的某个顶点的根元素
         * 输入的是下标查，如果两个元素的根元素相同，
         * 则这两个元素就是等价的。实际中还会有一个
         * 与vertexes等长的数组，装的是顶点的名字，
         * vertexes只是相当于代号，记录连通关系，
         * 二者通过下标，来映射真实顶点
         * @param vertexIndex 待查询的顶点下标
         * @return 该顶点的根顶点
         */
        public int find(int vertexIndex) {
            //如果记录小于0，那就是根顶点
            if (vertexes[vertexIndex] < 0) {
                //返回根顶点
                return vertexIndex;

            //如果记录不小于0，那还不是根，
            //是等价森林中的上一个节点
            } else {
                //递归向上继续寻找根
                return find(vertexes[vertexIndex]);
            }
        }

        /**
         * 将不相交集类(并查集)的两个顶点进行连通操作
         * 注意，两个顶点连通，代表这两个顶点所在的子树
         * 全部变成一个图中的大的子树。如果这
         * 两个顶点本来就连通，则不进行连通操作，舍弃该边。
         * 注意，这里同样是入参下标，下标映射真实顶点
         * 此实现类，根据树的高度来决定谁合并到谁上面，
         * 矮的树的根节点，会作为大的树的根节点的子节点
         * @param vertexIndex1 顶点下标1
         * @param vertexIndex2 顶点下标2
         */
        public void union(int vertexIndex1, int vertexIndex2) {
            int root1 = find(vertexIndex1);
            int root2 = find(vertexIndex2);

            //如果两个顶点本就连通
            if (root1 == root2) {
                //不作处理
                return;
            }

            //比高度：如果root1比root2的树要高
            if (vertexes[root1] < vertexes[root2]) {
                //将较矮的root2合并到较高的root1上
                vertexes[root2] = root1;

            //比高度：如果root2比root1的树要高
            } else if (vertexes[root2] < vertexes[root1]) {
                //将较矮的root1合并到较高的root2上
                vertexes[root1] = root2;

            //比高度：如果root1和root2一样高
            } else {
                //将root1合并到root2上
                vertexes[root1] = root2;

                //root2的高度增加1
                root2 --;
            }
        }
    }

    /**
     * 用不相交集类作为辅助，用克鲁斯卡尔(Kruskal)算法求出示例图的最小生成树
     * @param edgeList 图的所有边的List
     * @param vertexNum 图的顶点的个数
     * @param vertexName 图的顶点的
     * @return 组成示例图的最小生成树的所有边
     */
    public static List<Edge> runKruskalByDisjointSet(List<Edge> edgeList, int vertexNum, String[] vertexName) {
        //最后组成示例图的最小生成树的边的集合
        List<Edge> findKruskalEdges = new ArrayList<>();
        
        //将所有的边，按照权重从小到大排序
        Collections.sort(edgeList);
        
        //创建不相交集类的实例，本例我们用按高度求并的不相交集类，并初始化每个顶点都不连通
        DisjointSetUnionByHeight disjointSet = new DisjointSetUnionByHeight(vertexNum);
        
        //按权重从小到大，遍历每一条边
        for (Edge edge : edgeList) {
            //找到当前边的第一个顶点的根顶点
            int rootVertex1 = disjointSet.find(edge.getVertex1());
            
            //找到当前边的第二个顶点的根顶点
            int rootVertex2 = disjointSet.find(edge.getVertex2());
            
            //如果当前边的两个顶点，不连通(不在等价集合里就不连通)
            if (rootVertex1 != rootVertex2) {
                //接受当前边，并作为最小生成树中的一条边
                findKruskalEdges.add(edge);
                
                //合并当前边的两个顶点(也就是连通这两个顶点)
                disjointSet.union(edge.getVertex1(), edge.getVertex2());
                
                //输出算法的操作过程
                System.out.println(String.format("边: (%s -- %s), 权重: %d : 接受",
                        vertexName[edge.getVertex1()], vertexName[edge.getVertex2()],edge.getWeight()));
            
            //如果当前边的两个顶点是连通的
            } else {
                //舍弃当前边，也就是最小生成树不该包含当前边，并输出算法的操作过程
                System.out.println(String.format("边: (%s -- %s), 权重: %d : 舍弃",
                        vertexName[edge.getVertex1()], vertexName[edge.getVertex2()],edge.getWeight()));
            }
            
            //如果接收的边的数量已经达到顶点数-1了
            if (findKruskalEdges.size() == vertexNum - 1) {
                //表示所有顶点均已连通，最小生成树已求得
                break;
            }
        }
        
        //结束用不相交集类作为辅助的克鲁斯卡尔(Kruskal)算法
        //并返回最终组成最小生成树的所有边
        return findKruskalEdges;
    }

    /**
     * 验证用不相交集类作为辅助的克鲁斯卡尔(Kruskal)算法
     * 求出示例图的最终组成最小生成树的所有边
     * @param args
     */
    public static void main(String[] args) {
        //将示例图中的所有边，初始化并放入edgeList
        List<Edge> edgeList = new ArrayList<>();
        edgeList.add(new Edge(0, 3, 1));
        edgeList.add(new Edge(5, 6, 1));
        edgeList.add(new Edge(0, 1, 2));
        edgeList.add(new Edge(2, 3, 2));
        edgeList.add(new Edge(1, 3, 3));
        edgeList.add(new Edge(0, 2, 4));
        edgeList.add(new Edge(3, 6, 4));
        edgeList.add(new Edge(2, 5, 5));
        edgeList.add(new Edge(4, 6, 6));
        
        //示例图的顶点数为7
        int vertexNum = 7;
        
        //示例图的顶点下标对应的顶点名称
        String[] vertexName = {"V1", "V2", "V3", "V4", "V5", "V6", "V7"};

        //运行不相交集类作为辅助的克鲁斯卡尔(Kruskal)算法，
        //得到示例图的最小生成树的所有组成边
        List<Edge> acceptedEdgeList = runKruskalByDisjointSet(edgeList, vertexNum, vertexName);

		//空行
        System.out.println();
        
        //查看组成示例图的最小生成树的所有边
        for (Edge edge : acceptedEdgeList) {
            System.out.println(String.format("示例图的最小生成树的组成边：(%s -- %s)",
                    vertexName[edge.getVertex1()], vertexName[edge.getVertex2()]));
        }
    }

}

其中，图的边的类，以及不相交集类辅助类，都是以内部类实现的，运行 KruskalByDisjointSet 类的main方法，初始化示例图的边的参数和其他参数，运行 runKruskalByDisjointSet() 的算法驱动方法，输出结果如下（控制台输出，包括求示例图的最小生成树的算法运行过程中边的接受和舍弃的判断，以及最后求得的示例图的最小生成树的所有组成边的信息展示）：

边: (V1 -- V4), 权重: 1 : 接受
边: (V6 -- V7), 权重: 1 : 接受
边: (V1 -- V2), 权重: 2 : 接受
边: (V3 -- V4), 权重: 2 : 接受
边: (V2 -- V4), 权重: 3 : 舍弃
边: (V1 -- V3), 权重: 4 : 舍弃
边: (V4 -- V7), 权重: 4 : 接受
边: (V3 -- V6), 权重: 5 : 舍弃
边: (V5 -- V7), 权重: 6 : 接受

示例图的最小生成树的组成边：(V1 -- V4)
示例图的最小生成树的组成边：(V6 -- V7)
示例图的最小生成树的组成边：(V1 -- V2)
示例图的最小生成树的组成边：(V3 -- V4)
示例图的最小生成树的组成边：(V4 -- V7)
示例图的最小生成树的组成边：(V5 -- V7)

根据控制台的输出结果，可以说明：上述代码实现的算法已成功求得了示例图的最小生成树，而且用不相交集类作为辅助工具类，也很好地帮助判断了算法过程中边接受或舍弃操作的选择！

李先森LeeCode
关注
专栏目录
第十三章：数据结构-图的进阶(拓扑排序,最小生成树,加权无/有向图,Prim+kruskal算法)
Mr.Ding的博客
02-27 949
在实际生活中，很多应用相关的图都是有方向性的，最直观的就是网络，可以从A页面通过链接跳转到B页面，那么a和b连接的方向是a->b,但不能说是b->a,此时我们就需要使用有向图来解决这一类问题，它和我们之前学习的无向图，最大的区别就在于连接是具有方向的，在代码的处理上也会有很大的不同。
简单不相交集-1（基本应用-最小生成树）
knightzzy的专栏
05-04 779
最近学习简单不相交集(Disjoint-set)，理论比较复杂，但它的结构简单，容易实现。Disjoint-set记录一组集合S，其中任意两个合并的集合都是不相交的。该集合上的基本操作有三个：1、MakeSet(i)：建立一个新集合，其仅有的成员由i所指向。要求该元没有在其他集合中出现过。2、FindSet(i)：返回一个指向包含i集合代表的指针。3、Union(i, j)：将
cf1172B. Nauuo and Circle(全排列在圆上画边不相交的生成树 的种数)
qq_42576687的博客
01-20 273
题目 #include<bits/stdc++.h> using namespace std; const int N=2e5+5,mod=998244353; typedef long long ll; int deg[N]; int main(){ int n;scanf("%d",&n); ll ans=1; for(int i=1,x,y;i...
ADT: Disjoint Set 并查集（不相交集合）（Java 实现）
超悠閒的博客
12-11 407
ADT: Disjoint Set 并查集（不相交集合）（Java 实现） 文章目录ADT: Disjoint Set 并查集（不相交集合）（Java 实现）简介参考正文抽象接口描述基本 Java 实现接口定义具体实现类测试操作优化按秩合并路径压缩完整 Java 实现（带`按秩合并`和`路径压缩`）结语 简介 本篇来介绍并查集(disjoint-set)。很多时候我们会遇到这样一个场景，我们需要将许多各元素按照某种规则进行分类（也可以说是所谓的划分），我们可以举几个例子说明： 围棋游戏 在围棋游戏中每个
不相交集应用--kruskal算法
weixin_43913556的博客
11-17 1028
【问题描述】 已知含有n个顶点的带权连通无向图，采用邻接矩阵存储，邻接矩阵以三元组的形式给出，只给出不包括主对角线元素在内的下三角形部分的元素，且不包括不相邻的顶点对。分别采用prim算法和kruskal算法，求该连通图的最小生成树的权值之和。 【输入形式】 第一行给出结点个数n和三元组的个数count，以下每行给出一个三元组，数之间用空格隔开。（注意这里顶点的序号是从1到n，而不是0到n-1...
并查集（Disjoint Set）
破东风
08-12 948
并查集，一种比较基础的算法，主要是用于解决一些连通性的问题，通常这些问题
运用并查集与最小堆实现Kruskal算法
razorEdge的博客
12-01 4371
前言 Kruskal是在一个图（图论）中生成最小生成树的算法之一。（另外还有Prim算法，之后会涉及到）这就牵扯到了最小生成树的概念，其实就是总权值最小的一个连通无回路的子图。（结合下文的示意图不难理解）这里的代码并没有用图的存储结构（如：矩阵，邻接链表等）来处理和运用这个算法，而是最简单的三元组输入，这样会使得这个过程简化很多，至于图的存储方式，在之后总结图数据结构的时候会具体讨论。Kruska
最小生成树--Kruskal算法（Python）
编程&网站入门 ❤ 寸草&春晖
03-24 7864
给定一个无向图，如果它的生成子图是连通无圈的，那么我们就称之为生成树(Spanning Tree)。如果是带权值的无向图，那么权值之和最小的生成树，我们就称之为最小生成树(MST， Minimum Spanning Tree)。 **1、Kruskal算法描述** Kruskal算法是基于贪心的思想得到的。首先把所有的边按照权值从小到大排列，接着按照顺序选取每条边，如果这条边的...
算法之《图》Java实现
slw20010213的博客
12-09 802
数据结构之图 在前面我们所介绍的树的数据结构中，我们可以明显的感觉到，树的表示是分层的，例如父子关系，而其他关系只能间接的表示，例如同级关系。而图却不受这种限制。图是由顶点（或结点）及顶点之间的关系组成的集合。通常，图中的顶点数量或者一个顶点与其他顶点之间的连线的个数不受限制。（C++数据结构与算法） 定义(百度百科) 主要有以下两种定义。 二元组的定义： 图G是一个有序二元组(V,E)，其中V称为顶集(Vertices Set)，E称为边集(Edges set)，E与V不相交。它们亦可写成V(
如何利用并查集java实现最小生成树算法
在接下来的章节中，我们将深入探讨最小生成树算法概述、Kruskal算法基本原理、Prim算法的实现与优化等内容，帮助读者更好地掌握图论知识。 # 2. 最小生成树算法概述 最小生成树(Minimum Spanning Tr
Disjoint Set, 互质集合
acm160920007的博客
08-08 825
Disjoint Set,（一个元素不同时属于多个集合）。这里用森林结构代表集合集，树代表集合，根元素为代表元素   用rank数组记录数高。 FIndSet(x)  求包含元素晓得集合的代表元素， 在树中，查找x,后返回代表元素，同时压缩路径，将x，到根的所有节点指向根节点。降低搜索时间。 unite（x,y) 将树x,y合并。 将树高度低的加到树高的集合，使高度低的集合根节点指向高度高
java-并查集（Disjoint-set）-将多个集合合并成没有交集的集合
代码说-Let code talk
04-28 664
[code="java"] import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; i...
Kruskal算法
ACMLCER的博客
08-02 1003
算法实现思想及功能 Kruskal算法是求解最小生成树的一种算法。实现思想是首先将边按照权值大小排列，然后从权值最小的边开始加入最小生成树中，但是如果出现新加入的边与原来的图连成环，则不取该边。（这里使用查找根节点的方法实现，如果相同，则成环。如果不同，则加入，并把新加入的边的权值根节点更新。） 代码展示 #include <iostream> #include <cstring> #includ
数据结构与算法—并查集、Kruskal算法求最小生成树
我们都是被分成两半的人，一边热爱生活，一边憎恨生活。面对生活，我们总是在矛盾的两端摇摆，在反复的矛盾和犹豫中，一边踉跄前行，一边重振旗鼓。我渴望改变，渴望变得更好，渴望找到出口……就像一个溺水人的挣扎，就像一个救生圈。我是一个矛盾集合体，想要变得快乐，但是
12-22 427
数据结构—Kruskal算法求最小生成树并查集find函数 寻找最高上级find函数 路径压缩 寻找最高上级union函数 合并两无关边Kruskal算法求最小生成树题目一主要测试代码完整代码题目二题目三 并查集 并查集 （英文：Disjoint-set data structure，直译为不交集数据结构） 是一种 数据结构 ，用于处理一些 不交集 （Disjoint sets，一系列没有重复元素的集合）的合并及查询问题 一篇关于并查集很好的文章 在kruskal算法中，我们要用到并查集来判断新加入的边是否
并查集与最小生成树Kruskal算法
weixin_30477797的博客
12-24 144
并查集disjoint set 　　并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。 带路径优化的并查集 1 int findset(in...
图
a1059682127的博客
05-19 327
图的定义 定义 区别： 线性表：一对一，只有一个直接前驱和一个直接后继 树：一对多，明显的层次结构 图：是由顶点的有穷非空集合和顶点之间边的集合组成：G(V,E) 线性表中的数据元素叫元素，树中的元素叫节点，图中叫顶点 无向边：顶点vi到vj之间的边没有方向，则称该边为无向边，用无序偶对（vi,vj）表示...
二叉树问题
xinsuiqingfeng的博客
08-10 148
建立一个二叉树，求其高度，首先前、中、后序遍历，求叶子数，求数的深度并且判断是否为平衡二叉树。 #include<stdio.h> #include<stdlib.h> #define ERROR {puts("Error");return(1);} // ERROR用于处理程序的运行错误 typedef struct BiTNode // 二叉树要用的结构体 { ...
算法：用Java实现不相交集类(DisjointSet)，也叫并查集
weixin_39448458的博客
11-12 584
本文我用Java实现不相交集类(DisjointSet)的数据结构与算法。在这里先解释一下不相交集类，你可以想象成为刚开始有N个独立的元素，N个元素两两都不等价（不属于一个同等价集合，刚开始有N个等价集合，每个等价集合都只有一个元素，且这个元素就是等价集合的根元素，可以理解为等价集合的代表）。然后可以通过合并操作，把两个元素变为等价，随着后面合并操作的量越来越大，两个元素的合并就等于这两个元素所代表的两个等价集合的合并，最后合并成一个最大的等价集合。除了合并操作，还有寻找操作，就是寻找一个元素所在的等价集合
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值