数据结构之并查集

已于 2022-05-10 15:41:43 修改
阅读量968 收藏 1
点赞数 3
分类专栏： 2022 # 数据结构 文章标签： 数据结构 java
于 2022-05-09 21:29:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44289860/article/details/124670036
版权

1. 并查集（Union Find）

也叫做不相交集合（Disjoint Set）

  • 核心操作：
  1. 查找（Find）：查找元素所在的集合；
  2. 合并（Union）：将两个元素所在的集合合并为一个集合；

1.1 存储方式

假设并查集处理的数据都是整性，可以使用整性数组来存储数据。

  • 存储结构
    在这里插入图片描述
  • 逻辑结构
    在这里插入图片描述

可以看出：（0、1、3）是一个集合；（4、5、6、7）是一个集合；2自己一个集合。

1.2 抽象类设计

/**
 * @Description UnionFind 抽象类
 * @date 2022/5/9 20:28
 */
public abstract class AbstractUnionFind {

    protected int[] parents;

    public AbstractUnionFind(int capacity) {
        // 判断容量是否符合要求
        if (capacity < 0){
            throw new IllegalArgumentException("Capacity must >= 1");
        }
        // 创建基于容量大小的数组
        parents = new int[capacity];

        // 指向自己 让自己作为一个单独的集合
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
        }
    }

    /**
     * 检测索引是否合法
     * @param index
     */
    protected void rangeCheck(int index){
        if (index >= parents.length || index < 0){
            throw new IndexOutOfBoundsException("Index must less than array's length ");
        }
    }

    /**
     * 查找 v 的 所属集合（根节点）
     * @param v
     * @return
     */
    public abstract int find(int v);

    /**
     * 合并 v1 v2 的所属集合
     * @param v1
     * @param v2
     */
    public abstract void union(int v1, int v2);

     /**
     * 判断 v1 v2 是否属于同一个集合
     * @param v1
     * @param v2
     * @return
     */
    public boolean isSame(int v1, int v2){
        return find(v1) == find(v2);
    }
}

1.3 初始化

在执行初始化的时候，将值的父节点指向自己表示自己为一个单独的集合。

在这里插入图片描述

    private int[] parents;

    public QuickFind(int capacity) {
        // 判断容量是否符合要求
        if (capacity < 0){
            throw new IllegalArgumentException("Capacity must >= 1");
        }
        // 创建基于容量大小的数组
        parents = new int[capacity];

        // 指向自己 让自己作为一个单独的集合
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
        }
    }

1.4 Quick Find方式实现并查集

1.4.1 union

union(v1, v2)将v1集合的所有元素都指向v2集合的根节点。

  • 初始化之后：在这里插入图片描述
  • union(1, 0)：将1指向0的根节点。
    在这里插入图片描述
  • union(1,2)：将1所指向节点的所有原始的根节点都改为2的根节点在这里插入图片描述
  • 代码实现：
    @Override
    public void union(int v1, int v2) {
        // 获取两个值所在的集合（根节点值）
        int p1 = find(v1);
        int p2 = find(v2);
        // 如果根节点相同 就表示位于同一个集合中不需要合并
        if (p1 == p2) return;

        // 遍历数组中所有的元素，如果根节点与 v1 相同的都改为 v2 的根节点
        for (int i = 0; i < parents.length; i++) {
            if (parents[i] == p1){
                parents[i] = p2;
            }
        }
    }
1.4.2 find

直接返回数组中存储的根节点即可。

    /**
     * 检测索引是否合法
     * @param index
     */
    private void rangeCheck(int index){
        if (index >= parents.length || index < 0){
            throw new IndexOutOfBoundsException("Index must less than array's length ");
        }
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        // 因为这里直接指向的就是根节点，所以直接返回即可
        return parents[v];
    }
1.4.3 总结
  1. union()的时间复杂度为O(n)；
  2. find()的时间复杂度为O(1)。

1.5 QuickUnion

1.5.1 union

union(v1, v2)将v1集合的根节点都指向v2集合的根节点。

  • 初始化之后：在这里插入图片描述
  • union(1, 0)：将1的根节点指向0的根节点：
    在这里插入图片描述
  • union(1,2)：将1的根节点指向2的根节点：
    在这里插入图片描述
  • union(4,1)：将4的根节点指向1的根节点：
    在这里插入图片描述
    @Override
    public void union(int v1, int v2) {
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;
        // 将当前节点的父节点改为要修改的节点的父节点
        parents[p1] = p2;
    }
1.5.2 find
    @Override
    public int find(int v) {
        rangeCheck(v);
        // 一直往上找 知道当前元素的父节点是自己就表示为根节点
        while (v != parents[v]){
            v = parents[v];
        }
        return v;
    }
1.5.3 优化

在进行union()时，可以会出现树不平很的情况，甚至有可能会退化成链表。

在这里插入图片描述

1.5.3.1 基于size的优化

元素少的树嫁接到元素多的树上。

在这里插入图片描述

/**
 * @Description QuickUnion size 优化版本
 * @date 2022/5/9 20:48
 */
public class QuickUnionSize extends AbstractUnionFind{

    // 记录当前元素的数量
    private int[] sizes;

    public QuickUnionSize(int capacity) {
        super(capacity);
        sizes = new int[capacity];
        // 将当前元素的数量默认为 1
        for (int i = 0; i < sizes.length; i++) {
            sizes[i] = 1;
        }
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        // 一直往上找 知道当前元素的父节点是自己就表示为根节点
        while (v != parents[v]){
            v = parents[v];
        }
        return v;
    }

    @Override
    public void union(int v1, int v2) {
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;
        // 将数量少的嫁接到数量多的上面
        if (sizes[p1] < sizes[p2]){
            parents[p1] = p2;
            sizes[p2] += sizes[p1];
        }else {
            parents[p2] = p1;
            sizes[p1] += sizes[p2];
        }
    }
}
1.5.3.2 基于rank的优化

矮的树嫁接到高的树上。

在这里插入图片描述

/**
 * @Description QuickUnion rank 优化版本
 * @date 2022/5/9 20:48
 */
public class QuickUnionRank extends AbstractUnionFind{

    // 记录 '树' 的高度
    private int[] ranks;

    public QuickUnionRank(int capacity) {
        super(capacity);
        ranks = new int[capacity];
        // 将当前 ‘树’ 的高度默认为 1
        for (int i = 0; i < ranks.length; i++) {
            ranks[i] = 1;
        }
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        // 一直往上找 知道当前元素的父节点是自己就表示为根节点
        while (v != parents[v]){
            v = parents[v];
        }
        return v;
    }

    @Override
    public void union(int v1, int v2) {
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;
        // 将矮的树嫁接到高的树上
        if (ranks[p1] < ranks[p2]){
            parents[p1] = p2;
        }else if (ranks[p1] > ranks[p2]){
            parents[p2] = p1;
        }else {
            parents[p1] = p2;
            ranks[p2] += 1;
        }
    }
}
1.5.3.3 基于rank的优化 —— 路径压缩

在find()时，将路径上的所有节点都指向根节点，从而降低树的高度。

在这里插入图片描述

/**
 * @Description rank优化 —— 路径压缩
 * @date 2022/5/9 21:11
 */
public class QuickUnionPC extends AbstractUnionFind{
    // 记录 '树' 的高度
    private int[] ranks;

    public QuickUnionPC(int capacity) {
        super(capacity);
        ranks = new int[capacity];
        // 将当前 ‘树’ 的高度默认为 1
        for (int i = 0; i < ranks.length; i++) {
            ranks[i] = 1;
        }
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        // 递归调用 只要当前元素的父节点不是自己就一直往上并且赋值为根节点
        if (v != parents[v]){
            parents[v] = find(parents[v]);
        }
        return parents[v];
    }

    @Override
    public void union(int v1, int v2) {
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;
        // 将矮的树嫁接到高的树上
        if (ranks[p1] < ranks[p2]){
            parents[p1] = p2;
        }else if (ranks[p1] > ranks[p2]){
            parents[p2] = p1;
        }else {
            parents[p1] = p2;
            ranks[p2] += 1;
        }
    }
}
1.5.3.4 基于rank的优化 —— 路径分裂

find()时，使路径上的每个节点都指向其祖父节点。

在这里插入图片描述

/**
 * @Description rank优化 —— 路径减半
 * @date 2022/5/9 21:11
 */
public class QuickUnionPS extends AbstractUnionFind{
    // 记录 '树' 的高度
    private int[] ranks;

    public QuickUnionPS(int capacity) {
        super(capacity);
        ranks = new int[capacity];
        // 将当前 ‘树’ 的高度默认为 1
        for (int i = 0; i < ranks.length; i++) {
            ranks[i] = 1;
        }
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        // 让元素的父节点改为祖父节点
        while (v != parents[v]){
            int p = parents[v];
            parents[v] = parents[parents[v]];
            v = p;
        }
        return parents[v];
    }

    @Override
    public void union(int v1, int v2) {
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;
        // 将矮的树嫁接到高的树上
        if (ranks[p1] < ranks[p2]){
            parents[p1] = p2;
        }else if (ranks[p1] > ranks[p2]){
            parents[p2] = p1;
        }else {
            parents[p1] = p2;
            ranks[p2] += 1;
        }
    }
}
1.5.3.5 基于rank的优化 —— 路径减半

find()时，使路径上每隔一个节点就指向其祖父节点。

在这里插入图片描述

/**
 * @Description rank优化 —— 路径减半
 * @date 2022/5/9 21:11
 */
public class QuickUnionPV extends AbstractUnionFind{
    // 记录 '树' 的高度
    private int[] ranks;

    public QuickUnionPV(int capacity) {
        super(capacity);
        ranks = new int[capacity];
        // 将当前 ‘树’ 的高度默认为 1
        for (int i = 0; i < ranks.length; i++) {
            ranks[i] = 1;
        }
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        // 让元素的父节点改为祖父节点
        while (v != parents[v]){
            parents[v] = parents[parents[v]];
            v = parents[v];
        }
        return v;
    }

    @Override
    public void union(int v1, int v2) {
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;
        // 将矮的树嫁接到高的树上
        if (ranks[p1] < ranks[p2]){
            parents[p1] = p2;
        }else if (ranks[p1] > ranks[p2]){
            parents[p2] = p1;
        }else {
            parents[p1] = p2;
            ranks[p2] += 1;
        }
    }
}
1.5.4 总结
  • 优化之前的：
  1. union()的时间复杂度为O(n)；
  2. find()的时间复杂度为O(n)。
  • 使用 rang或者size在添加以下三个中的一个路径分裂、路径减半、路径压缩之后：可以使两个操作的均摊时间复杂度优化为：O(α(n))其中α(n) < 5。
  • 建议使用QuickUnion基于Rank优化再添加路径分裂或者路径减半。

1.6 自定义类型

使用链表 + map 实现自定义类型。

/**
 * @Description 自定义类型union find
 * @date 2022/5/10 15:22
 */
public class UnionFindObj<V> {

    private Map<V, Node<V>> nodes = new HashMap<>();

    // 初始化集合
    public void makeSet(V v){
        if (nodes.containsKey(v))return;
        nodes.put(v, new Node<V>(v));
    }

    public V find(V v){
        Node<V> node = findNode(v);
        return node == null ? null : node.v;
    }

    /**
     * 找到 v 对应的根节点
     * @param v
     * @return
     */
    private Node<V> findNode(V v){
        // 当前 v 对应的节点
        Node<V> node = nodes.get(v);

        if (node == null) return null;

        // 如果当前节点与父节点的值不相同就不是根节点
        while (!Objects.equals(node.v,node.parent.v)){
            // 路径减半操作
            node.parent = node.parent.parent;
            node = node.parent;
        }

        return node;
    }

    public void union(V v1, V v2){
        Node<V> node1 = findNode(v1);
        Node<V> node2 = findNode(v2);
        if (node1 == null || node2 == null) return;
        if (Objects.equals(node1.v,node2.v)) return;

        if (node1.rank < node2.rank){
            node1.parent = node2;
        }else if (node1.rank > node2.rank){
            node2.parent = node1;
        }else {
            node1.parent = node2;
            node2.rank += 1;
        }

    }

    public boolean isSame(V v1, V v2){
        return Objects.equals(find(v1),find(v2));
    }

    private static class Node<V>{
        V v;
        // 创建节点时parent指向自己
        Node<V> parent = this;
        int rank = 1;
        public Node(V v) {
            this.v = v;
        }
    }
}


/**
 * @Description
 * @date 2022/5/10 15:25
 */
@Data
@AllArgsConstructor
@ToString
public class Student {
    private int age;
    private String name;
}
江海i
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（八）：并查集详解 （多图+动图）
ReadyGo!!!的博客
07-03 1万+
数据结构（八）：并查集详解 （多图+动图）
并查集
谦小白
01-13 5万+
文章目录一、并查集定义二、并查集思想三、并查集代码：(1)初始化(2)查找(3)合并四、路径压缩 一、并查集定义 1. 并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。 2. 并查集通常包含两种操作 查找(Find)：查询两个元素是否在同一个集合中 合并(Union)：把两个不相交的集合合并为一个集合 注意：双亲结点就是父结点 二、并查集思想 如图现在大陆上有下面六位鼎鼎大名的忍者，且各自为王！     &
并查集（disjoint sets）
qq_42388742的博客
01-11 4346
并查集（disjoint sets）学习笔记(python、C语言) 这个月刷leetcode已经遇到了三次并查集问题，前两次都看太难放过，今天又遇到就先尝试解决，看到师弟桌子上《挑战程序设计竞赛》这本书上有这个知识点，这里写下笔记记录。 文章目录并查集（disjoint sets）学习笔记(python、C语言)前言一、并查集是什么？二、并查集的结构1. 初始化2. 合并3. 查询并查集实现的注意点查并集的复杂度并查集的实现示例 LeetCode 1202. 交换字符串中的元素总结 前言 并查集是一
万字长文，并查集（Union Find）精讲及应用实例
白话机器学习
06-06 4146
并查集（Union Find）：一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。不交集指的是一系列没有重复元素的集合。合并（Union）：将两个集合合并成一个集合。查找（Find）：确定某个元素属于哪个集合。通常是返回集合内的一个「代表元素」。简单来说，并查集就是用来处理集合的合并和集合的查询。并查集中的「集」指的就是我们初中所学的集合概念，在这里指的是不相交的集合，即一系列没有重复元素的集合。
并查集(Union-Find) (图文详解)
qq_57469718的博客
06-22 9730
并查集 数据结构 算法 Leetcode
c语言数据结构之并查集 总结
12-31
并查集(Union-Find Set)： 一种用于管理分组的数据结构。它具备两个操作：(1)查询元素a和元素b是否为同一组 (2) 将元素a和b合并为同一组。 注意：并查集不能将在同一组的元素拆分为两组。 并查集的实现： 用树来实现...
数据结构之并查集（模板）
08-17
并查集实现，带路径压缩和template，高效查找神器！注：库里面如果没有unordered_map，可以换成hash_map或者map
ACM-数据结构-并查集学习
02-20
ACM-数据结构-并查集学习
数据结构并查集 查询 快速
05-29
数据结构 并查集 查询 快速 实用 ACM
【算法与数据结构】—— 并查集
热门推荐
酱懵静的博客
03-26 13万+
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。 数组 pre[ ] 记录了每个点的前驱节点是谁，函数 find(x) 用于查找指定节点 x 属于哪个集合，函数 join(x,y) 用于合并两个节点 x 和 y 。
并查集是什么？怎么模拟实现？如何应用？
CYK_byte的博客
01-16 1944
我们可以想象这样一个过程，开始时有n个元素，某些元素开始和其他元素按照一定规律进行集合合并，有可能就会分成几个集合。在这个过程中要反复某个元素是哪个集合的，这样的运算，被抽象成数据类型叫做“并查集”；还是不太理解？举个例子例如：现在有10个人，分别对其进行编号，下标都为-1（为什么是-1，后面会解释），如下图：现在将这个一个个零散人组建成如下三个团体：解释：1. 数组的下标对应集合中元素的编号2. 数组中如果为负数，负号表示当前下标为根结点，数字代表该集合中元素个数。
（详细版）并查集---图论
眼泪划过的星空
03-26 1327
并查集的概念： 并查集是一种可以用来判断同属一个集合中相互关联的元素属于几个集合，也可以用来判断图结构中的两点是否是连通。并查集是一种树型的数据结构，用于处理一些不相交集合(Disjoint Sets)的合并及查询问题。常常在使用中以森林来表示。 并查集的应用 1，一般来说，可以用来合并集合元素，确定结合数量，查找元素处于哪个集合的位置。 2. 在图结构里，确定两个结点是否处于连通状态，尤其在图的应用中广泛涉及。 并查集的常见结构 基本函数: 用于初始化-----Init(n) ; 用于查..
【数据结构】--并查集
m0_63077733的博客
04-08 1245
初始化时，每个元素各自属于一个单元素集合i++) {不是固定的让某一棵树嫁接到另一棵树，让元素少的树 嫁接到 元素多的树。/*** Quick Union--基于size的优化*/// 该数组存放以size[i]为根节点的节点个数i++){// 初始化一个根节点只有一个节点【就是它本身】sizes[i]=1;/*** 将v1所在的根节点 嫁接到v2的根节点上*/@Overridereturn;//如果v1所在的树的长度<v2所在的树的长度，则将v1嫁接到v2上。
并查集(不相交集)详解
qq_64580912的博客
03-13 1847
并查集（Disjoint-set Union 或 Union-find）是一种数据结构，用于维护一些不相交（disjoint）的集合，支持合并两个集合以及判断两个元素是否属于同一个集合。并查集可以使用树来实现，每个集合可以看做是一棵树，代表元素是根节点。使用路径压缩可以减少查找操作的时间复杂度，使用按秩合并可以减少合并操作的时间复杂度，使得并查集的时间复杂度可以达到近乎常数级别，因此在一些算法中广泛应用，比如 Kruskal 算法和 Tarjan 算法。
并查集(Disjoint Set)
m0_61506053的博客
06-29 1398
并查集 数据结构
并查集理解与简单应用(入门详细版)
qq_51774501的博客
11-18 1097
这个东西估计下节算法设计与分析课又要小组讨论和提问，为了防止小组其他成员被突然背刺，回来想想还是写一篇介绍一下吧。不过好在这个知识同时也在考研的范围之内，就当复习数据结构了╮(╯﹏╰）╭。
并查集（详细解释+完整C语言代码）
weixin_54186646的博客
04-28 1万+
并查集的详细逻辑梳理与完整代码实现，包括查询、合并、路径压缩等操作。
数据结构并查集 c语言
最新发布
09-26
并查集是一种常用的数据结构，它可以用来解决一些关于元素之间连通性的问题。在C语言中，我们可以通过数组来实现并查集。首先，我们需要初始化每个元素的根节点，使其指向自己。下面是一个用C语言实现的并查集的例子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值