【数据结构】UnionFind 并查集-2

已于 2023-02-27 19:30:19 修改
阅读量449 收藏
点赞数
分类专栏： 算法与数据结构 # 数据结构 文章标签： 数据结构
于 2021-12-08 16:31:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fisherish/article/details/121794576
版权

在这里插入图片描述

数据结构源码 - UnionFind1

接口

public interface UnionFind {

    int getSize();

    boolean isConnected(int p, int q);

    void unionElements(int p, int q);
}

实现类

import java.util.Random;

/**
 * 第二种UnionFind实现
 */
public class UnionFind4 implements UnionFind {

    private int[] parent;

    private int[] rank;  // rank[i]表示以i为根的集合所表示的树的层数

    public UnionFind4(int size) {
        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

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

    /**
     * 查找过程，查找元素p所对应的集合编号
     * O(h)复杂度，h为树高度
     * @param p
     * @return
     */
    private int find(int p) {
        if (p < 0 && p >= parent.length)
            throw new IllegalArgumentException("p is out of bound");

        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    /**
     * 查看元素p和元素q是否所属一个集合
     * @param p
     * @param q
     * @return
     */
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    /**
     * 合并元素p和元素q所属的集合
     * O(h)复杂度，h为树的高度
     * @param p
     * @param q
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot)
            return;

        // 根据两个元素所在树的元素个数不同判断合并方向
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
        }
        else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        }
        else {  // rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }

    private static double testUF(UnionFind uf, int m) {

        int size = uf.getSize();

        Random random = new Random();

        long startTime = System.nanoTime();

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }


    public static void main(String[] args) {
        int size = 100000;
        int m = 100000;

        UnionFind1 uf1 = new UnionFind1(size);
        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");

        UnionFind2 uf2 = new UnionFind2(size);
        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");

        UnionFind4 uf4 = new UnionFind4(size);
        System.out.println("UnionFind4 : " + testUF(uf4, m) + " s");
    }
}

数据结构拆解 - UnionFind4

维护字段和内部类


    private int[] parent;

    private int[] rank;  // rank[i]表示以i为根的集合所表示的树的层数

构造函数


    public UnionFind4(int size) {
        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

改



    /**
     * 合并元素p和元素q所属的集合
     * O(h)复杂度，h为树的高度
     * @param p
     * @param q
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot)
            return;

        // 根据两个元素所在树的元素个数不同判断合并方向
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
        }
        else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        }
        else {  // rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }

查



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

    /**
     * 查找过程，查找元素p所对应的集合编号
     * O(h)复杂度，h为树高度
     * @param p
     * @return
     */
    private int find(int p) {
        if (p < 0 && p >= parent.length)
            throw new IllegalArgumentException("p is out of bound");

        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    /**
     * 查看元素p和元素q是否所属一个集合
     * @param p
     * @param q
     * @return
     */
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

测试用例 - UnionFind4



    private static double testUF(UnionFind uf, int m) {

        int size = uf.getSize();

        Random random = new Random();

        long startTime = System.nanoTime();

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }


    public static void main(String[] args) {
        int size = 100000;
        int m = 100000;

        UnionFind1 uf1 = new UnionFind1(size);
        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");

        UnionFind2 uf2 = new UnionFind2(size);
        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");

        UnionFind4 uf4 = new UnionFind4(size);
        System.out.println("UnionFind4 : " + testUF(uf4, m) + " s");
    }

数据结构源码 - UnionFind5

接口

public interface UnionFind {

    int getSize();

    boolean isConnected(int p, int q);

    void unionElements(int p, int q);
}

实现类

import java.util.Random;

/**
 * 第二种UnionFind实现
 */
public class UnionFind5 implements UnionFind {

    private int[] parent;

    private int[] rank;  // rank[i]表示以i为根的集合所表示的树的层数

    public UnionFind5(int size) {
        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

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

    /**
     * 查找过程，查找元素p所对应的集合编号
     * O(h)复杂度，h为树高度
     * @param p
     * @return
     */
    private int find(int p) {
        if (p < 0 && p >= parent.length)
            throw new IllegalArgumentException("p is out of bound");

        while (p != parent[p]) {
            parent[p] = parent[parent[p]];
            p = parent[p];
        }
        return p;
    }

    /**
     * 查看元素p和元素q是否所属一个集合
     * @param p
     * @param q
     * @return
     */
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    /**
     * 合并元素p和元素q所属的集合
     * O(h)复杂度，h为树的高度
     * @param p
     * @param q
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot)
            return;

        // 根据两个元素所在树的元素个数不同判断合并方向
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
        }
        else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        }
        else {  // rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }

    private static double testUF(UnionFind uf, int m) {

        int size = uf.getSize();

        Random random = new Random();

        long startTime = System.nanoTime();

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }


    public static void main(String[] args) {
        int size = 10000000;
        int m = 10000000;

//        UnionFind1 uf1 = new UnionFind1(size);
//        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");
//
//        UnionFind2 uf2 = new UnionFind2(size);
//        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");

        UnionFind4 uf4 = new UnionFind4(size);
        System.out.println("UnionFind4 : " + testUF(uf4, m) + " s");

        UnionFind5 uf5 = new UnionFind5(size);
        System.out.println("UnionFind5 : " + testUF(uf5, m) + " s");
    }
}

数据结构拆解 - UnionFind5

维护字段和内部类


    private int[] parent;

    private int[] rank;  // rank[i]表示以i为根的集合所表示的树的层数

构造函数



    public UnionFind5(int size) {
        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

改

    /**
     * 合并元素p和元素q所属的集合
     * O(h)复杂度，h为树的高度
     * @param p
     * @param q
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot)
            return;

        // 根据两个元素所在树的元素个数不同判断合并方向
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
        }
        else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        }
        else {  // rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }

查


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

    /**
     * 查找过程，查找元素p所对应的集合编号
     * O(h)复杂度，h为树高度
     * @param p
     * @return
     */
    private int find(int p) {
        if (p < 0 && p >= parent.length)
            throw new IllegalArgumentException("p is out of bound");

        while (p != parent[p]) {
            parent[p] = parent[parent[p]];
            p = parent[p];
        }
        return p;
    }

    /**
     * 查看元素p和元素q是否所属一个集合
     * @param p
     * @param q
     * @return
     */
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

测试用例 - UnionFind5


    private static double testUF(UnionFind uf, int m) {

        int size = uf.getSize();

        Random random = new Random();

        long startTime = System.nanoTime();

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }


    public static void main(String[] args) {
        int size = 10000000;
        int m = 10000000;

//        UnionFind1 uf1 = new UnionFind1(size);
//        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");
//
//        UnionFind2 uf2 = new UnionFind2(size);
//        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");

        UnionFind4 uf4 = new UnionFind4(size);
        System.out.println("UnionFind4 : " + testUF(uf4, m) + " s");

        UnionFind5 uf5 = new UnionFind5(size);
        System.out.println("UnionFind5 : " + testUF(uf5, m) + " s");
    }
锥栗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言数据结构之并查集 总结
12-31
并查集(Union-Find Set)： 一种用于管理分组的数据结构。它具备两个操作：(1)查询元素a和元素b是否为同一组 (2) 将元素a和b合并为同一组。 注意：并查集不能将在同一组的元素拆分为两组。 并查集的实现： 用树来实现...
并查集（Union-Find）介绍.zip
04-12
并查集.并查集（Union-Find）是一种特殊的数据结构，它可以高效地管理一系列不交集的合并和查询操作。这种数据结构通常用树形结构来表示，并且常常在实际应用中以森林的形式存在。
【算法与数据结构】—— 并查集
热门推荐
酱懵静的博客
03-26 13万+
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。 数组 pre[ ] 记录了每个点的前驱节点是谁，函数 find(x) 用于查找指定节点 x 属于哪个集合，函数 join(x,y) 用于合并两个节点 x 和 y 。
数据结构之并查集Union-Find Sets
GarfieldEr007的专栏
03-28 1265
1、  概述 并查集（Disjoint set或者Union-find set）是一种树型的数据结构，常用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。 2、  基本操作 并查集是一种非常简单的数据结构，它主要涉及两个基本操作，分别为： A． 合并两个不相交集合 B． 判断两个元素是否属于同一个集合 （1）       合并两个不相
数据结构之并查集 Union Find 剖析
chen
03-15 480
数据结构之并查集 Union Find 剖析 文章目录数据结构之并查集 Union Find 剖析概述原理时间复杂度分析实现实现Quick Find并查集实现Quick Union并查集考虑size优化并查集基于rank优化并查集路径压缩优化并查集Leetcode 547. Friend Circles相关链接公众号参考 概述 并查集（英文：Disjoint-set data structure，直译为不交集数据结构）： 是一种数据结构， 用于处理一些不交集（Disjoint sets，一系列没有重复元素
并查集（Union-Find）
小朱小朱绝不认输的博客
05-26 854
并查集是一种巧妙的算法思想，主要解决连通性问题的场景，比如：一组对象被划分成了若干个区域，求解被划分区域的数量，或者求解如何将这几个区域连接起来。 文章目录1. 并查集（Union-Find）算法介绍1.1 动态连通性1.2 union-find算法API2 union-find的实现2.1 quick-find算法2.2 quick-union算法2.3 加权quick-union算法2.4 使用路径压缩的加权quick-union算法2.5 算法比较 1. 并查集（Union-Find）算法介绍 1.1
数据结构与算法——并查集（Union-Find）
jay_zzs的博客
09-03 463
1. 原理/概念 并查集（Union-Find）主要用来解决无向图的【动态连通性】问题，对于无向图的连通，一般具有如下几个性质： 自反性：节点p和 p 是连通的； 对称性：如果节点 p 和节点 q 连通，那么节点 q 和 p 也是连通的； 传递性：如果节点 p 和 q 连通， q 和 r 连通，那么 p 和 r 连通。 本文参考一个大神labuladong的算法小抄：Union-Find算法详解，主页在这。 注意，并查集只能用来解决无向图的连通性的问题，如果是有向图，要找其强连通分量，需要用t..
数据结构--并查集
信息学奥赛学案
07-04 986
并查集
【数据结构】并查集(Union Find)
qq_43478625的博客
12-31 601
并查集需求分析概述如何存储数据接口定义初始化为Quick Find和Quick Union定义抽象类Quick Find示例查找方法合并方法具体实现测试Quick Union示例 需求分析 假设有n个村庄,有些村庄之间有连接的路,有些村庄之间并没有连接的路 设计一个数据结构,能够快速执行两个操作 查询2个村庄之间是否有连接的路 连接2个村庄 数组、链表、平衡二叉树、集合(Set)? 查询、连接的时间复杂度都是: O(n) 并查集能够办到查询、连接的均摊复杂度都是O(α(n)), α
数据结构与算法（十二）并查集(Union Find)及时间复杂度分析
Chiclaim
06-17 4万+
本文主要包括以下内容： 并查集的概念 并查集的操作 并查集的实现和优化 Quick Find Quick Union 基于size的优化 基于rank的优化 路径压缩优化 并查集的时间复杂度 并查集的概念 在计算机科学中，并查集 是一种树形的数据结构，用于处理不交集的合并(union)及查询(find)问题。 并查集 可用于查询 网络 中两个节点的状态， 这里的网络是一个抽象的概...
数据结构——并查集Union Find
zp的博客
10-29 586
一、并查集解决了什么问题？ 1、网络中节点间的连接状态：这里的网络是一个抽象的概念，指的是用户之间形成的网络 2、两个或两个以上集合之间的交集   二、对并查集的设计 对于一组数据，主要支持两个操作 public interface UnionFind { //int getSize(); boolean isConnected(int p , int q); ...
数据结构--并查集的进一步优化
m0_60593173的博客
07-11 497
压缩路径−−Find操作，先找到根节点，再将查找路径上所有结点都挂到根结点下每次Find操作，先找根，再“压缩路径”，可使树的高度不超过Oαn))。αn是一个增长很缓慢的函数，对于常见的n值，通常αn≤4，因此优化后并查集的Find、Union操作时间开销都很低。
数据结构：并查集 Union-Find算法(不相交集)原理及C++实现.zip
12-29
数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 ...
数据结构--并查集(Union-Find Sets)
05-14
数据结构并查集的相关资料，包括几篇并查集的论文，还有POJ上面几道关于并查集的题目的源代码
c++初级并查集知识点总结
01-01
并查集是一种树型的数据结构，用于处理一些不交集的合并及查询问题。 有一个联合- 查找算法定义了两个用于此数据结构的操作： Find ：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。 Union...
冒泡排序和选择排序算法
weixin_61898502的博客
06-02 212
冒泡算法和选择算法
【数据结构】平衡二叉树（AVL树）
lyhv_v的博客
06-06 505
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年发明了一种方法，用以解决上述问题。一、AVL树概念AVL 树是一种平衡二叉树，得名于其发明者的名字（ Adelson-Velskii 以及 Landis）。（可见名字长的好处，命名都能多占一个字母出来）。左右子树的高度差小于等于 1。其每一个子树均为平衡二叉树。
排序---快速排序的4次优化
最新发布
sunshine350的博客
06-06 341
“调优”
【排序】冒泡排序
2302_80220453的博客
05-31 565
在我们的生活中，到处都离不开排序的作用，考试分数要排序，商场购物要排序，可以说排序对我们来说处处存在，那么从本章开始，我将要依次分享一些排序方法，从易到难，包括冒泡，插入，快速，希尔，选择等排序方法，希望大家能够支持。
并查集优化union
12-23
两种方法可以结合使用，通过路径压缩和按秩合并，可以使并查集的find和union操作的平均时间复杂度均摊下降到接近常数级别，从而实现对并查集操作的优化。这种优化方法在实际应用中经常使用，特别是在大规模数据的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

锥栗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值