首页 > 编程语言> 文章详细

Day34-数据结构与算法-并查集

2020-12-19 11:58:26 阅读：230 来源： 互联网

标签：capacity int Day34 查集 QuickUnion parents 数据结构 public

title: Day34-数据结构与算法-并查集
date: 2020-12-14 17:59:00
author: 子陌

常用的经典数据结构

假设有n个村庄，有些村庄之间有连接的路，有些村庄之间并没有连接的路

并查集-需求分析

设计一个数据结构，能够快速执行2个操作
- 查询2个村庄之间是否有连接的路
- 连接2个村庄
数组、链表、平衡二叉树、集合(Set)？
- 查询、连接的时间复杂度都是：O(n)
并查集能够办到查询、连接的均摊时间复杂度都是O(α(n))，α(n) < 5
并查集非常适合解决这类“连接”相关的问题

并查集（Union Find）

并查集也叫做不相交集合（Disjoint Set）
并查集有2个核心操作
- 查找（Find）：查找元素所在的集合（这里的集合并不是特指Set这种数据结构，是指广义的数据集合）
- 合并（Union）：将两个元素所在的集合合并为一个集合
有2种常见的实现思路
- Quick Find
  - 查找（Find）的时间复杂度：O(1)
  - 合并（Union）的时间复杂度：O(n)
- Quick Union
  - 查找（Find）的时间复杂度：O(logn)，可以优化至O(α(n))，α(n) < 5
  - 合并（Union）的时间复杂度：O(logn)，可以优化至O(α(n))，α(n) < 5

如何存储数据

假设并查集处理的数据都是整型，那么可以用整型数组来存储数据

如何存储数据

因此，并查集是可以用数组实现的树形结构（二叉堆、优先级队列也是可以用数组实现的树形结构）

接口设计

int find(int v);查找v所属的集合（根节点）
void union(int v1, int v2);合并v1、v2所属的集合
boolean isSame(int v1, int v2);检查v1，v2是否属于同一个集合

初始化

初始化时，每个元素各自属于一个单元素集合

初始化

并查集公共抽象类抽取

package com.zimo.算法.并查集;

/**
 * 并查集 - 公共抽象类抽取
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/15 10:16
 */
public abstract class UnionFind {
    protected int[] parents;

    public UnionFind(int capacity) {
        if (capacity < 0){
            throw new IllegalArgumentException("capacity must be >= 1");
        }
        parents = new int[capacity];
        for (int i = 0; i < parents.length; i++) {
            parents[i] = i;
        }
    }

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

    /**
     * 合并v1、v2所在的集合
     */
    public abstract void union(int v1, int v2);

    /**
     * 检查v1、v2是否属于同一个集合
     * @return 返回检查结果
     */
    public boolean isSame(int v1, int v2){
        return find(v1) == find(v2);
    }

    protected void rangeCheck(int v){
        if (v < 0 || v >= parents.length) throw new IllegalArgumentException("v is out of bounds");
    }
}

Quick Find实现

合并时，将根节点涉及的所有子节点全部修改为新的根节点

Quick-Find

package com.zimo.算法.并查集.QuickFind;

import com.zimo.算法.并查集.UnionFind;

/**
 * 并查集 - Quick_Find
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/15 10:16
 */
public class QuickFind extends UnionFind {
    public QuickFind(int capacity) {
        super(capacity);
    }

    public int find(int v){
        rangeCheck(v);
        return parents[v];
    }

    /**
     * 将v1所在的集合所有元素，嫁接到v2的父节点上
     */
    public void union(int v1, int v2){
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;

        for (int i = 0; i < parents.length; i++) {
            if (parents[i] == p1){
                parents[i] = p2;
            }
        }
    }
}

Quick Union实现

合并时，将根点的根节点修改为新的根节点

Quick-Union

package com.zimo.算法.并查集.QuickUnion;

import com.zimo.算法.并查集.UnionFind;

/**
 * 并查集 - Quick_Union
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/15 18:00
 */
public class QuickUnion extends UnionFind {
    public QuickUnion(int capacity) {
        super(capacity);
    }

    /**
     * 通过parent链表不断地向上找，直到找到根节点
     */
    @Override
    public int find(int v) {
        rangeCheck(v);
        while (v != parents[v]){
            v = parents[v];
        }
        return v;
    }

    /**
     * 将v1的根节点嫁接到v2的根节点上
     */
    @Override
    public void union(int v1, int v2) {
        int p1 = find(v1);
        int p2 = find(v2);
        if (p1 == p2) return;
        parents[p1] = p2;
    }
}

Quick Union优化

在Union的过程中，可能会出现树不平衡的情况，甚至退化成链表
有两种常见的优化方案
- 基于size 的优化：元素少的树嫁接到元素多的树
- 基于rank的优化：矮的树嫁接到高的书
基于size的优化，也可能会存在树的不平衡问题

基于size 的优化

package com.zimo.算法.并查集.QuickUnion;

/**
 * 并查集 - Quick_Union - 基于size 的优化
 *      元素少的树 嫁接到 元素多的树
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/16 10:33:50
 */
public class QuickUnion_Size extends QuickUnion {
    private int[] sizes;
    public QuickUnion_Size(int capacity) {
        super(capacity);
        sizes = new int[capacity];
        for (int i = 0; i < capacity; i++) {
            sizes[i] = 1;
        }
    }

    @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];
        }
    }
}

基于rank的优化荐

package com.zimo.算法.并查集.QuickUnion;

/**
 * 并查集 - Quick_Union - 基于rank的优化
 *      矮的树 嫁接到 高的书
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/16 10:52:48
 */
public class QuickUnion_Rank extends QuickUnion {
    private int[] ranks;
    public QuickUnion_Rank(int capacity) {
        super(capacity);
        ranks = new int[capacity];
        for (int i = 0; i < capacity; i++) {
            ranks[i] = 1;
        }
    }

    @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.路径压缩优化（Path Compression Question）

虽然有了基于rank的优化，树会相对平衡一点
但是随着Union次数的增多，树的高度依然会越来越高
- 导致find操作变慢，尤其是底层节点(因为find是不断向上找到根节点)
什么是路径压缩?
- 在find时使路径上的所有节点都指向根节点，从而降低树的高度

路径压缩

package com.zimo.算法.并查集.QuickUnion;

/**
 * 并查集 - Quick_Union - 基于rank的优化 + 路劲压缩
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/16 10:52:48
 */
public class QuickUnion_RankPathCompression extends QuickUnion_Rank {

    public QuickUnion_RankPathCompression(int capacity) {
        super(capacity);
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        if (parents[v] != v){
            parents[v] = find(parents[v]);
        }
        return parents[v];
    }
}

路径压缩使路径上的所有节点都指向根节点，所以实现成本稍高
还有两种更优的做法，不但能降低树高，实现成本也比路径压缩低
- 路径分裂
- 路径减半
路径分裂、路径减半的效率差不多，但都比路径压缩要好

路径分裂-减半

2.路径分裂（Path Spliting）荐

路径分裂：使路径上的每个节点都指向其祖父节点（parent的parent）

package com.zimo.算法.并查集.QuickUnion;

/**
 * 并查集 - Quick_Union - 基于rank的优化 + 路劲分裂
 *      使路径上的每个节点都指向其祖父节点（parent的parent）
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/18 11:18:45
 */
public class QuickUnion_RankPathSpliting extends QuickUnion_Rank {

    public QuickUnion_RankPathSpliting(int capacity) {
        super(capacity);
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        while (v  != parents[v]){
            int p = parents[v];
            parents[v] = parents[parents[v]];
            v = p;
        }
        return v;
    }
}

3.路径减半（Path Halving）荐

路径减半：使路径上每隔一个节点就指向其祖父节点(parent的parent)

package com.zimo.算法.并查集.QuickUnion;

/**
 * 并查集 - Quick_Union - 基于rank的优化 + 路劲减半
 *      使路径上每隔一个节点就指向其祖父节点(parent的parent)
 *
 * @author Liu_zimo
 * @version v0.1 by 2020/12/18 11:33:12
 */
public class QuickUnion_RankPathHalving extends QuickUnion_Rank {

    public QuickUnion_RankPathHalving(int capacity) {
        super(capacity);
    }

    @Override
    public int find(int v) {
        rangeCheck(v);
        while (v  != parents[v]){
            parents[v] = parents[parents[v]];
            v = parents[v];
        }
        return v;
    }
}

总结

使用路径压缩、分裂或减半＋基于rank或者size的优化
- 可以确保每个操作的均摊时间复杂度为o(α(n))，α(n) < 5
推荐搭配
- Quick Union
- 基于Rank的优化
- Path Halving 或者Path Spliting

如果是自定义类型，想使用并查集

方案1：自定类型转成整型后使用并查集（比如生成哈希值）
方案2：使用链表 + 映射（Map）

标签：capacity,int,Day34,查集,QuickUnion,parents,数据结构,public
来源： https://blog.csdn.net/qq_38205875/article/details/111402333

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Day34-数据结构与算法-并查集

常用的经典数据结构

并查集（Union Find）

如何存储数据

接口设计

初始化

并查集公共抽象类抽取

Quick Find实现

Quick Union实现

Quick Union优化

基于size 的优化

基于rank的优化 荐

总结

基于rank的优化荐