并查集（JAVA）

最新推荐文章于 2024-04-10 13:13:47 发布
最新推荐文章于 2024-04-10 13:13:47 发布
阅读量166 收藏
点赞数
分类专栏： 学习笔记 文章标签： 数据结构 算法 并查集 JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cedarjo/article/details/91352345
版权

并查集接口

/**
 * 并查集
 */
public interface UnionFind {

    /**
     * 所有节点数量
     * @return
     */
    int count();

    /**
     * 将a和b合并
     * @param a
     * @param b
     */
    void union(int a, int b);

    /**
     * 查找a属于哪个集合
     * @param a
     * @return
     */
    int find(int a);

    /**
     * 查找a和b是否同属一个集合
     * @param a
     * @param b
     * @return
     */
    boolean isConnected(int a, int b);

}

值直接为所属集合id的并查集

public class UnionFindV1 implements UnionFind {

    private int[] id;

    public UnionFindV1(int capacity) {
        assert capacity > 0;
        this.id = new int[capacity];
        for (int i = 0; i < this.id.length; i++) {
            this.id[i] = i;
        }
    }

    @Override
    public int count() {
        return this.id.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < id.length;
        assert b >= 0 && b < id.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }

        // 将所有root为a的节点root改为b
        for (int i = 0; i < id.length; i++) {
            if (id[i] == aRoot) {
                id[i] = bRoot;
            }
        }
    }

    @Override
    public int find(int a) {
        return this.id[a];
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < id.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : id) {
            sb.append(i).append('\t');
        }
        return sb.toString();
    }
}

有关联的并查集

public class UnionFindV2 implements UnionFind {

    private int[] parent;

    public UnionFindV2(int capacity) {
        this.parent = new int[capacity];
        for (int i = 0; i < this.parent.length; i++) {
            this.parent[i] = i;
        }
    }

    @Override
    public int count() {
        return this.parent.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < this.parent.length;
        assert b >= 0 && b < this.parent.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }
        this.parent[aRoot] = bRoot;
    }

    @Override
    public int find(int a) {
        assert a >= 0 && a < this.parent.length;

        while (a != this.parent[a]) {
            a = this.parent[a];
        }
        return a;
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < this.parent.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : this.parent) {
            sb.append(find(i)).append('\t');
        }
        return sb.toString();
    }

}

基于size的优化

import java.util.Arrays;

public class UnionFindBaseSize implements UnionFind {

    private int[] parent;
    private int[] unionSize;

    public UnionFindBaseSize(int capacity) {
        this.parent = new int[capacity];
        for (int i = 0; i < this.parent.length; i++) {
            this.parent[i] = i;
        }
        this.unionSize = new int[capacity];
        Arrays.fill(this.unionSize, 1);
    }

    @Override
    public int count() {
        return this.parent.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < this.parent.length;
        assert b >= 0 && b < this.parent.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }
        // 少的挂到多的上
        if (this.unionSize[aRoot] < this.unionSize[bRoot]) {
            this.parent[aRoot] = bRoot;
            this.unionSize[bRoot] += this.unionSize[aRoot];
        } else {
            this.parent[bRoot] = aRoot;
            this.unionSize[aRoot] += this.unionSize[bRoot];
        }
    }

    @Override
    public int find(int a) {
        assert a >= 0 && a < this.parent.length;

        while (a != this.parent[a]) {
            a = this.parent[a];
        }
        return a;
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < this.parent.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : this.parent) {
            sb.append(find(i)).append('\t');
        }
        return sb.toString();
    }

}

基于rank的优化

import java.util.Arrays;

public class UnionFindBaseRank implements UnionFind {

    private int[] parent;
    private int[] rank;

    public UnionFindBaseRank(int capacity) {
        this.parent = new int[capacity];
        for (int i = 0; i < this.parent.length; i++) {
            this.parent[i] = i;
        }
        this.rank = new int[capacity];
        Arrays.fill(this.rank, 1);
    }

    @Override
    public int count() {
        return this.parent.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < this.parent.length;
        assert b >= 0 && b < this.parent.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }
        // 层数少的挂层数多的
        if (this.rank[aRoot] < this.rank[bRoot]) {
            this.parent[aRoot] = bRoot;
        } else if (this.rank[aRoot] > this.rank[bRoot]) {
            this.parent[bRoot] = aRoot;
        } else {
            // 层数相等时，随意挂，但被挂上的根要rank++
            this.parent[bRoot] = aRoot;
            this.rank[aRoot] += 1;
        }
    }

    @Override
    public int find(int a) {
        assert a >= 0 && a < this.parent.length;

        while (a != this.parent[a]) {
            a = this.parent[a];
        }
        return a;
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < this.parent.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : this.parent) {
            sb.append(find(i)).append('\t');
        }
        return sb.toString();
    }

}

基于size优化+路径压缩

两步一压缩

import java.util.Arrays;

/**
 * 基于size优化后再做路径压缩
 */
public class UnionFindBaseSizePathCompressionV1 implements UnionFind {

    private int[] parent;
    private int[] unionSize;

    public UnionFindBaseSizePathCompressionV1(int capacity) {
        this.parent = new int[capacity];
        for (int i = 0; i < this.parent.length; i++) {
            this.parent[i] = i;
        }
        this.unionSize = new int[capacity];
        Arrays.fill(this.unionSize, 1);
    }

    @Override
    public int count() {
        return this.parent.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < this.parent.length;
        assert b >= 0 && b < this.parent.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }
        // 少的挂到多的上
        if (this.unionSize[aRoot] < this.unionSize[bRoot]) {
            this.parent[aRoot] = bRoot;
            this.unionSize[bRoot] += this.unionSize[aRoot];
        } else {
            this.parent[bRoot] = aRoot;
            this.unionSize[aRoot] += this.unionSize[bRoot];
        }
    }

    @Override
    public int find(int a) {
        assert a >= 0 && a < this.parent.length;

        while (a != this.parent[a]) {
            this.parent[a] = this.parent[this.parent[a]];
            a = this.parent[a];
        }
        return a;
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < this.parent.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : this.parent) {
            sb.append(find(i)).append('\t');
        }
        return sb.toString();
    }

}

直接压缩到根

import java.util.Arrays;

/**
 * 基于size优化后再做路径压缩
 */
public class UnionFindBaseSizePathCompressionV2 implements UnionFind {

    private int[] parent;
    private int[] unionSize;

    public UnionFindBaseSizePathCompressionV2(int capacity) {
        this.parent = new int[capacity];
        for (int i = 0; i < this.parent.length; i++) {
            this.parent[i] = i;
        }
        this.unionSize = new int[capacity];
        Arrays.fill(this.unionSize, 1);
    }

    @Override
    public int count() {
        return this.parent.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < this.parent.length;
        assert b >= 0 && b < this.parent.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }
        // 少的挂到多的上
        if (this.unionSize[aRoot] < this.unionSize[bRoot]) {
            this.parent[aRoot] = bRoot;
            this.unionSize[bRoot] += this.unionSize[aRoot];
        } else {
            this.parent[bRoot] = aRoot;
            this.unionSize[aRoot] += this.unionSize[bRoot];
        }
    }

    @Override
    public int find(int a) {
        assert a >= 0 && a < this.parent.length;

        if (a != this.parent[a]) {
            this.parent[a] = find(this.parent[a]);
        }
        return a;
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < this.parent.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : this.parent) {
            sb.append(find(i)).append('\t');
        }
        return sb.toString();
    }

}

基于rank优化+路径压缩

两步一压缩

import java.util.Arrays;

/**
 * 基于rank优化后再做路径压缩
 */
public class UnionFindBaseRankPathCompressionV1 implements UnionFind {

    private int[] parent;
    private int[] unionSize;

    public UnionFindBaseRankPathCompressionV1(int capacity) {
        this.parent = new int[capacity];
        for (int i = 0; i < this.parent.length; i++) {
            this.parent[i] = i;
        }
        this.unionSize = new int[capacity];
        Arrays.fill(this.unionSize, 1);
    }

    @Override
    public int count() {
        return this.parent.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < this.parent.length;
        assert b >= 0 && b < this.parent.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }
        // 少的挂到多的上
        if (this.unionSize[aRoot] < this.unionSize[bRoot]) {
            this.parent[aRoot] = bRoot;
            this.unionSize[bRoot] += this.unionSize[aRoot];
        } else {
            this.parent[bRoot] = aRoot;
            this.unionSize[aRoot] += this.unionSize[bRoot];
        }
    }

    @Override
    public int find(int a) {
        assert a >= 0 && a < this.parent.length;

        while (a != this.parent[a]) {
            this.parent[a] = this.parent[this.parent[a]];
            a = this.parent[a];
        }
        return a;
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < this.parent.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : this.parent) {
            sb.append(find(i)).append('\t');
        }
        return sb.toString();
    }

}

直接压缩到根

import java.util.Arrays;

/**
 * 基于rank优化后再做路径压缩
 */
public class UnionFindBaseRankPathCompressionV2 implements UnionFind {

    private int[] parent;
    private int[] unionSize;

    public UnionFindBaseRankPathCompressionV2(int capacity) {
        this.parent = new int[capacity];
        for (int i = 0; i < this.parent.length; i++) {
            this.parent[i] = i;
        }
        this.unionSize = new int[capacity];
        Arrays.fill(this.unionSize, 1);
    }

    @Override
    public int count() {
        return this.parent.length;
    }

    @Override
    public void union(int a, int b) {
        assert a >= 0 && a < this.parent.length;
        assert b >= 0 && b < this.parent.length;

        int aRoot = find(a);
        int bRoot = find(b);
        if (aRoot == bRoot) {
            return;
        }
        // 少的挂到多的上
        if (this.unionSize[aRoot] < this.unionSize[bRoot]) {
            this.parent[aRoot] = bRoot;
            this.unionSize[bRoot] += this.unionSize[aRoot];
        } else {
            this.parent[bRoot] = aRoot;
            this.unionSize[aRoot] += this.unionSize[bRoot];
        }
    }

    @Override
    public int find(int a) {
        assert a >= 0 && a < this.parent.length;

        if (a != this.parent[a]) {
            this.parent[a] = find(this.parent[a]);
        }

        return a;
    }

    @Override
    public boolean isConnected(int a, int b) {
        return find(a) == find(b);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("index:\t");
        for (int i = 0; i < this.parent.length; i++) {
            sb.append(i).append('\t');
        }
        sb.append("\nroot:\t");
        for (int i : this.parent) {
            sb.append(find(i)).append('\t');
        }
        return sb.toString();
    }

}

性能测试

import java.lang.reflect.Constructor;
import java.util.Random;

import org.junit.Test;

public class TestUF {

    @Test
    public void unionFind() {
        int capacity = 10000000;
        // unionFindTest(UnionFindV1.class, capacity);
        // unionFindTest(UnionFindV2.class, capacity);
        unionFindTest(UnionFindBaseSize.class, capacity);
        unionFindTest(UnionFindBaseSizePathCompressionV1.class, capacity);
        unionFindTest(UnionFindBaseSizePathCompressionV2.class, capacity);
        unionFindTest(UnionFindBaseRank.class, capacity);
        unionFindTest(UnionFindBaseRankPathCompressionV1.class, capacity);
        unionFindTest(UnionFindBaseRankPathCompressionV2.class, capacity);
    }

    private void unionFindTest(Class<? extends UnionFind> clazz, int capacity) {
        try {
            Random random = new Random(37);
            Constructor<? extends UnionFind> constructor = clazz.getConstructor(int.class);
            UnionFind unionFind = constructor.newInstance(capacity);
            long start = System.currentTimeMillis();
            for (int i = 0; i < capacity; i++) {
                int a = random.nextInt(capacity);
                int b = random.nextInt(capacity);
                unionFind.union(a, b);
            }
            for (int i = 0; i < capacity; i++) {
                int a = random.nextInt(capacity);
                int b = random.nextInt(capacity);
                unionFind.isConnected(a, b);
            }
            System.out.println(clazz.getSimpleName() + " , capacity is " + capacity + " time is "
                    + (System.currentTimeMillis() - start) / 1000.0 + "s");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
晋韩野
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现并查集
08-18
主要为大家详细介绍了Java实现并查集，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java实现快速并查集
08-18
主要为大家详细介绍了Java实现快速并查集，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
算法与数据结构——并查集(Java版)
yss233333的博客
12-17 2858
并查集
Java——并查集
m0_60867520的博客
12-17 1385
并查集的概念及应用，实现一个并查集并测试，图文并茂，要点齐全
Java并查集(含面试大厂题和源码)
最新发布
2302_80314137的博客
04-10 1029
并查集（Union-Find）是一种用于处理一些不交集合合并及集合间元素查找问题的数据结构。它提供了两个主要的操作：查找（Find）和合并（Union）。查找操作用于确定某个元素属于哪个集合，而合并操作用于将两个集合合并为一个集合。
Java—并查集
ZXC1562307245的博客
11-25 1324
并查集是一种树型的数据结构，用于处理一些的及问题。并查集的思想：用一个数组表示了整片森林（parent），树的根节点唯一标识一个集合，只要找到了某个元素的的树根，就能确它在哪个集合里。
并查集（java详细实现）
这个人很懒，什么都没有写
07-12 576
查询两个元素是否在同一个集合中，以及合并两个不相交集合。当然我们可以用链表等其他数据结构来实现，担当数据量特别大的时候，使用链表是非常耗时的，采用并查集结构可以大大提高合并及查询的效率。初始化并查集时，我们将每一个元素的根节点都指向自己。根节点，下文成为 “ 代表节点 ”：并查集也是一种树的结构，
玩转数据结构之Java实现并查集
故不积跬步无以至千里
02-16 422
并查集（Union-Find）就是用来对集合进行 合并（Union） 与 查询（Find） 操作的一种数据结构;合并就是将两个不相交的集合合并成一个集合；查询就是查询两个元素是否属于同一集合；并查集详解ღ( ´･ᴗ･` )
Java使用HashMap实现并查集
08-25
主要为大家详细介绍了Java使用HashMap实现并查集，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java实现的并查集的代码示例
01-20
Java实现的并查集的代码示例
java编程实现并查集的路径压缩代码详解
08-28
主要介绍了java编程实现并查集的路径压缩代码详解，具有一定借鉴价值，需要的朋友可以参考。
并查集（java）
iGxy0929的博客
01-14 1400
并查集是一种用于管理元素所属集合的数据结构，实现为一个森林，其中每棵树表示一个集合，树中的节点表示对应集合中的元素。
Java数据结构-并查集
qq_51938362的博客
10-16 690
Java并查集
数据结构之并查集（Java实现）
qq_41939120的博客
06-29 340
并查集；使用java实现
【算法】并查集（Java）
每天更新大数据面经和技术
04-22 4690
  今天学习一种新的数据结构并查集。“并”表示合并，“查”表示查找，“集”表示集合。其基本思想是用 father[i] 表示元素 i 的父节点。例如 father[1] = 2 表示元素 1 的父节点是 2。如果 father[i] = i，那么说明 i 是根节点，根节点作为一个集合的标识，如下图表示两个集合，它们的根节点分别是 1 和 5。当然，如果不使用数组来记录，而使用 map 来记录，那么可以使用 father.get(i) = null 来表示根节点。 1.并查集的基本操作 下面定义了并查集的类
Java数据结构与算法（并查集）
博客包含书籍、B站、其他博主博客等内容，只为了记录笔记，作业，问题，软件配置等，为了以后方便查阅，如有侵权，请联系删除
07-25 596
一般像计算机这样网络型的数据，我们要求网络中的每两个数据之间都是相连通的，也就是说，我们需要调用很多次union方法，使得网络中所有数据相连，其实我们很容易可以得出，如果要让网络中的数据都相连，则我们至少要调用N-1次union方法才可以，但由于我们的union方法中使用for循环遍历了所有的元素，所以很明显，我们之前实现的合并算法的时间复杂度是O(N^2)，如果要解决大规模问题，它是不合适的，所以我们需要对算法进行优。如果我们并查集存储的每一个整数表示的是一个大型计算机网络中的计算机，则我们就可以通过。.
并查集
AN_ERA的博客
08-21 3343
需求描述 假设有n个村庄，有些村庄之间有连接的路，有些村庄之间并没有连接的路 设计一个数据结构，能够快速执行2个操作: 查询2个村庄之间是否有连接的路 连接2个村庄 使用数组、链表、平衡二叉树、集合(Set),查询、连接的时间复杂度都是: O(n) 并查集能够办到查询、连接的均摊时间复杂度都是 O(α(n)), α(n) < 5 并查集非常适合解决这类“连接”相关的问题 基础概念 并查集也叫作不相交集合(Disjoint Set) 并查集有2个核心操作查找(Find): 查找.
并查集（Java实现）
Rkun18的博客
01-20 1462
任务： 维护多个不相交的集合，支持两种操作：合并两个集合，查询一个元素所在的集合。 说明： 维护一个森林，每一棵树都代表一个集合，树根元素为这个集合的代表元。利用数组father[]查询记录每个元素的父亲节点。 查询一个元素所处集合时，只需不断寻找父节点，即可找到该元素所处集合的代表元。 合并两个集合时，先找到两个集合代表元x,y,然后令father[x]=y即可。 优化： 路径压缩，沿着树根的路径找到元素a所在集合代表元b后，对这条路径上的所有元素x，令father[a]=b;
并查集的Java实现
07-28
以下是并查集的Java实现示例： ```java class UnionFind { private int[] parent; private int[] rank; public UnionFind(int size) { this.parent = new int[size]; this.rank = new int[size]; // 初始...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值