Union-Find 算法（并查集）

最新推荐文章于 2024-04-26 21:57:57 发布
最新推荐文章于 2024-04-26 21:57:57 发布
阅读量2.7k 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法 普林斯顿 coursera
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/disappearedgod/article/details/25210091
版权
作者：disappearedgod
时间：2014-5-7

前言

参考《算法》第四版的内容，并融入了Algorithm，Part I（Princeton）的讲义

0. 介绍

这里讨论的是一个网络连接的问题。看图画中的两个点是否能够连接上。

1. 动态连通性

问题的输入是一列整数对，其中每个整数都表示一个某种类型的对象，一对整数p q可以被理解为"p和q是相连的 "。我们假设“相连”是一种对等的关系，也就意味着：
  • 自反性：p和p是相连的
  • 对称性：如果p和q是相连的，那么q和p也是相连的
  • 传递性：如果p和q是相连的且q和r是相连的，那么p和r也是相连的。
上述对等关系能够将对象分为多个等价类（当且仅当两个对象相连时它们才属于同一个等价类）。

也就是，当程序从输入中读取了整数对（p q）时，如果一直的所有整数对都不能说明p和q是相连的，那么则将这一对整数写到输出中。如果已知的数据可以说明p和q是相连的，那么程序应该忽略（p q）这对整数并继续处理输入中的下一对整数。
我们设计了一份API来封装所需的基本操作:初始化、连接两个触点、判断包含某个触点的分量、判断两个触点是否存在于同一个分量之中以及返回所有分量的数量。
public class UF
UF(int N)                                                initialize N sites with integer names (0 to N-1)
void union(int p, int q)                             add connection between p and q
int find(int p)                                          component identifier for p (0 to N-1)
boolean connected(int p, int q)                return true if p and q are in the same component
int count()                                              number of components

所有的实现都应该：
定义一种数据结构表示一直的连接
基于此数据结构实现高效的union()、find()、connected()和count()方法

我们的目的是找到一条路径：

首先，先看一下UF的测试用例

public static void main(String[] args) {
        int N = StdIn.readInt();//对象的个数
        UF uf = new UF(N);
        while (!StdIn.isEmpty()) {//输入整数对
            int p = StdIn.readInt();
            int q = StdIn.readInt();
            if (uf.connected(p, q)) continue;
            uf.union(p, q);
            StdOut.println(p + " " + q);
        }
        StdOut.println(uf.count() + " components");
    }



测试用例的一个输入是：

10
4 3
3 8
6 5
9 4
2 1
8 9
5 0
7 2
6 1
1 0
6 7


2. 实现

对于上述这样的动态连接问题，我们用下面几种方法进行数显。

2.1 quick-find 算法

2.1.1 算法介绍

我们想构造这样一种数据类型


其实，我们用了一个一下这个方法（例如添加一条边1-6）


我们举几个例子吧：

先从0-链接开始


链接操作union(4,3) 就是把id为4的数值改为id为3的数值

、




connected（）判断是否有链接




如下图来做这个操作


2.1.2 算法实现

根据上述介绍，我们可以写这样段代码

public class QuickFindUF {
    private int[] id;    // id[i] = component identifier of i
    private int count;   // number of components

    /**
     * Initializes an empty union-find data structure with N isolated components 0 through N-1.
     * @throws java.lang.IllegalArgumentException if N < 0
     * @param N the number of objects
     */
    public QuickFindUF(int N) {
        count = N;
        id = new int[N];
        for (int i = 0; i < N; i++)
            id[i] = i;
    }  

    /**
     * Are the two sites <tt>p</tt> and <tt>q/tt> in the same component?
     * @param p the integer representing one site
     * @param q the integer representing the other site
     * @return <tt>true</tt> if the two sites <tt>p</tt> and <tt>q</tt> are in
     *    the same component, and <tt>false</tt> otherwise
     * @throws java.lang.IndexOutOfBoundsException unless both 0 <= p < N and 0 <= q < N
     */
    public boolean connected(int p, int q) {
        return id[p] == id[q];
    }
  
    /**
     * Merges the component containing site<tt>p</tt> with the component
     * containing site <tt>q</tt>.
     * @param p the integer representing one site
     * @param q the integer representing the other site
     * @throws java.lang.IndexOutOfBoundsException unless both 0 <= p < N and 0 <= q < N
     */
    public void union(int p, int q) {
        if (connected(p, q)) return;
        int pid = id[p];
        for (int i = 0; i < id.length; i++)
            if (id[i] == pid) id[i] = id[q]; 
        count--;
    }
	
	/**
     * Returns the number of components.
     * @return the number of components (between 1 and N)
     */
    public int count() {
        return count;
    }
	/**
     * Returns the component identifier for the component containing site <tt>p</tt>.
     * @param p the integer representing one site
     * @return the component identifier for the component containing site <tt>p</tt>
     * @throws java.lang.IndexOutOfBoundsException unless 0 <= p < N
     */
    public int find(int p) {
        return id[p];
    }
}

2.1.3 算法分析

在quick-find 算法中，每次find()调用只需要访问数组一次，而归并两个分量的union()操作访问数组的次数在(N+3)到(2N+1)之间。（uion中调用两次find()，jiancha id[]数组中全部N个元素并改变他们中的1到N-1个元素）。

如果最终结果是只得到一个连通分量(所有数组值都相同)，只扫调用（N-1）次union,即至少需要N+3TimesN-1次——N^2次操作。


2.2 quick-union 算法

2.2.1 介绍

这个算法主要是提高了union()方法的速度，它和quick-find方法互补。

他也是基于相同的数据结构（id数组），单赋予了不同的意义。这里采用了树（根）的概念。

我们由p和q的链接分别找到它们的根触点，然后只需要将一个根触点链接到另一个即可，讲一个分量重命名为另一个分量，因此叫做quick-union。

我现在看一下是如何做Union() 和Connect()的


Union(a,b)是将b的根节点作为a的根节点的根节点








connect(a,b)是看他们的根节点是否相同




下面看一下这个例子中的树是如何建立的


2.2.2实现


public class QuickUnionUF {
    private int[] id;    // id[i] = parent of i
    private int count;   // number of components

    /**
     * Initializes an empty union-find data structure with N isolated components 0 through N-1.
     * @throws java.lang.IllegalArgumentException if N < 0
     * @param N the number of objects
     */
    public QuickUnionUF(int N) {
        id = new int[N];
        count = N;
        for (int i = 0; i < N; i++) {
            id[i] = i;
        }
    }

    

    /**
     * Returns the component identifier for the component containing site <tt>p</tt>.
     * @param p the integer representing one site
     * @return the component identifier for the component containing site <tt>p</tt>
     * @throws java.lang.IndexOutOfBoundsException unless 0 <= p < N
     */
    public int find(int p) {
        while (p != id[p])
            p = id[p];
        return p;
    }

    /**
     * Are the two sites <tt>p</tt> and <tt>q</tt> in the same component?
     * @param p the integer representing one site
     * @param q the integer representing the other site
     * @return <tt>true</tt> if the sites <tt>p</tt> and <tt>q</tt> are in the same
     *    component, and <tt>false</tt> otherwise
     * @throws java.lang.IndexOutOfBoundsException unless both 0 <= p < N and 0 <= q < N
     */
    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

  
    /**
     * Merges the component containing site<tt>p</tt> with the component
     * containing site <tt>q</tt>.
     * @param p the integer representing one site
     * @param q the integer representing the other site
     * @throws java.lang.IndexOutOfBoundsException unless both 0 <= p < N and 0 <= q < N
     */
    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) return;
        id[rootP] = rootQ; 
        count--;
    }

    /**
     * Returns the number of components.
     * @return the number of components (between 1 and N)
     */
    public int count() {
        return count;
    }
    


}

2.2.3 评价

这个方法的最好的时间复杂度是线性的，最坏时间复杂度也还是平方的。


好处是：quick-union 算法看做是quick-find算法的一种改良，因为它解决了quick-find算法中最主要的问题（Union（）操作总是线性级别的）。

我们发现最坏时间复杂度高是因为树的深度太深。

2.3 加权quick-union算法

2.3.1 介绍

简单的修改quick-union算法就能保证最坏情况不能发生。我们将记录每一棵树的大小并总是将较小的树链接到较大的树上。这项改动需要添加一个数组和一些代码在记录树中的节点数。


2.3.2 实现

public class WeightedQuickUnionUF {
    private int[] id;    // id[i] = parent of i
    private int[] sz;    // sz[i] = number of objects in subtree rooted at i
    private int count;   // number of components

    /**
     * Initializes an empty union-find data structure with N isolated components 0 through N-1.
     * @throws java.lang.IllegalArgumentException if N < 0
     * @param N the number of objects
     */
    public WeightedQuickUnionUF(int N) {
        count = N;
        id = new int[N];
        sz = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
            sz[i] = 1;
        }
    }

    /**
     * Returns the number of components.
     * @return the number of components (between 1 and N)
     */
    public int count() {
        return count;
    }

    /**
     * Returns the component identifier for the component containing site <tt>p</tt>.
     * @param p the integer representing one site
     * @return the component identifier for the component containing site <tt>p</tt>
     * @throws java.lang.IndexOutOfBoundsException unless 0 <= p < N
     */
    public int find(int p) {
        while (p != id[p])
            p = id[p];
        return p;
    }

    /**
     * Are the two sites <tt>p</tt> and <tt>q</tt> in the same component?
     * @param p the integer representing one site
     * @param q the integer representing the other site
     * @return <tt>true</tt> if the two sites <tt>p</tt> and <tt>q</tt>
     *    are in the same component, and <tt>false</tt> otherwise
     * @throws java.lang.IndexOutOfBoundsException unless both 0 <= p < N and 0 <= q < N
     */
    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

  
    /**
     * Merges the component containing site<tt>p</tt> with the component
     * containing site <tt>q</tt>.
     * @param p the integer representing one site
     * @param q the integer representing the other site
     * @throws java.lang.IndexOutOfBoundsException unless both 0 <= p < N and 0 <= q < N
     */
    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) return;

        // make smaller root point to larger one
        if   (sz[rootP] < sz[rootQ]) { id[rootP] = rootQ; sz[rootQ] += sz[rootP]; }
        else                         { id[rootQ] = rootP; sz[rootP] += sz[rootQ]; }
        count--;
    }



}

2.3.3 评价

下图为例子输入构造和上述最坏情况


对于100个点做88次union方法来说


2.4 总结

各种UF的性能比较


所有操作的总成本（横轴为链接总数，纵轴为访问数组的次数）


disappearedgod
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Union-Find算法详解
流楚丶格念的博客
06-01 3436
原文地址：https://www.jianshu.com/p/5f0db63ba54b今天讲讲 Union-Find 算法，也就是常说的并查集算法，主要是解决图论中「动态连通性」问题的。名词很高端，其实特别好理解，等会解释，另外这个算法的应用都非常有趣。说起这个 Union-Find，应该算是我的「启蒙算法」了，因为《算法4》的开头就介绍了这款算法，可是把我秀翻了，感觉好精妙啊！后来刷了 LeetCode，并查集相关的算法题目都非常有意思，而且《算法4》给的解法竟然还可以进一步优化，只要加一个微小的修改就可
union-find（并查集）算法
trina121的博客
01-07 2725
背景: union-find算法是用来解决动态连通性问题的。 动态连通性问题的数学表达: 问题的输入是一列整数对。一个整数对可以被理解成这个整数对的两个整数相连。 eg：我们输入整数对 p,q，那么"p和q是相连的"。 相连:我们假设相连是一种对等的关系，就意味着它有 自反性:p和p是相连的 对称性:如果p和q相连，那么q和p也是相连的 传递性:如果p和q是相连的，q和r是相连的，那么p和r而是相连的 问题:我们已知一些整数对(即所有点的相连关系)，那么如何得知某两个点是否相连? 现实中的例子: 大型网
并查集算法（union-find）
夜夜夜夜
04-27 834
就动态连通性这个场景而言，我们需要解决的问题可能是： 给出两个节点，判断它们是否连通，如果连通，不需要给出具体的路径 给出两个节点，判断它们是否连通，如果连通，需要给出具体的路径就上面两种问题而言，虽然只有是否能够给出具体路径的区别，但是这个区别导致了选择算法的不同，本文主要介绍的是第一种情况，即不需要给出具体路径的Union-Find算法，而第二种情况可以使用基于DFS的算法。 题目1：畅通
【算法基础实验】图论-UnionFind连通性检测之quick-find
最新发布
Greyplayground
04-26 1361
Union-Find 是解决连通性问题的一种非常高效的数据结构。它能够快速合并集合并快速判断元素之间的连通性。通过路径压缩和按秩合并的优化，Union-Find 在实际应用中可以接近常数时间完成操作。因此，它在算法竞赛、网络连接和社交网络分析等领域有广泛的应用。
数据结构与算法（十二）并查集(Union Find)及时间复杂度分析
Chiclaim
06-17 4万+
本文主要包括以下内容： 并查集的概念 并查集的操作 并查集的实现和优化 Quick Find Quick Union 基于size的优化 基于rank的优化 路径压缩优化 并查集的时间复杂度 并查集的概念 在计算机科学中，并查集 是一种树形的数据结构，用于处理不交集的合并(union)及查询(find)问题。 并查集 可用于查询 网络 中两个节点的状态， 这里的网络是一个抽象的概...
并查集（UnionFind）原理及优化过程
m0_51625685的博客
10-23 1091
并查集 并查集：并查集也叫不相交集合。具有两个核心操作： 查找元素在哪个集合里 将两个集合联合在一起 在实际使用中，也通常判断两个元素是否在同一个集合里面。 一个小小的例子 这张图里有12个村庄。不同的村庄之间有不同的连接情况。那么如何在代码中做到连接两个村庄，判断两个村庄之间是否有路能够互通呢？ 这就要用到并查集。 并查集的代码实现主要可以分为Quick Find和Quick Union. 实现代码1-Quick Find 我们在底层用数组来实现。 数组中某个位置的元素就代表着这个位置元素的pare
union-find算法（并查集）
li1358159的博客
02-14 884
任何一种算法都是为解决某个问题而生的，union-find是用于解决动态连通性问题的一种算法。
并查集(Union-Find)算法
Broken_Wave的博客
08-26 552
并查集（Union-Find）是解决动态连通性问题的一类非常高效的数据结构。 动态连通性 可以想象一张地图上有很多点，有些点之间是有道路相互联通的，而有些点则没有。如果我们现在要从点A走向点B，那么一个关键的问题就是判断我们能否从A走到B呢？换句话说，A和B是否是连通的。这是动态连通性最基本的诉求。现在给出一组数据，其中每个元素都是一对“点”，代表这对点之间是联通的，我们需要设计一个算法，让计...
并查集（Union-Find）介绍.zip
04-12
并查集（Union-Find）是一种用于处理连接关系的数据结构，它在计算机科学中有着广泛的应用，尤其是在图论、算法设计以及数据结构的学习中。这个数据结构的主要目标是高效地解决“查找”和“合并”两个操作，常用于...
数据结构：并查集 Union-Find算法(不相交集)原理及C++实现.zip
12-29
数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 ...
【数据结构与算法】——并查集
雪月清的博客
04-14 3067
并查集：一种树型数据结构，用于解决一些不相交集合的合并及查询问题。例如：有n个村庄，查询2个村庄之间是否有连接的路，连接2个村庄 两大核心： 查找 (Find) : 查找元素所在的集合 合并 (Union) : 将两个元素所在集合合并为一个集合 并查集有两种常见的实现思路：快查、快并
基于Union-Find的Kruskal算法C++实现
05-14
基于Union-Find数据结构实现Kruskal求最小生成树，代码设计及变量命名附详细注释。基于Union-Find数据结构实现Kruskal求最小生成树，代码设计及变量命名附详细注释。
unionfind:一种用于 Python 的快速联合查找数据结构
06-20
unionfind unionfind是 Python/Cython 中不相交集森林数据结构的简单、快速实现。 该模块定义了一个类UnionFind ，其元素是连续的整数索引。 用法 使用pip安装（需要构建 cython）。 通过编写unionfind.UnionFind(n) import unionfind并在n 个元素上创建森林。 使用find(i)方法find(i)索引为i的点的根。 使用union(i, j)方法union(i, j)包含i和j的集合，为方便起见，该方法还返回结果集的根。 使用n_sets属性查看森林中有多少不相交的集合。 完整文档中更详细地描述了上述内容。 要构建文档，首先使用pip安装模块， cd到doc目录，然后make html 。
Union-Find算法
weixin_30546189的博客
11-20 180
Union-Find算法 简介 原理 改进 应用 References Union-Find算法 1.简介 Union-Find算法又称并查集算法，是一种作用于并查集数据结构的算法。包含两个主要的操作： - Find 用于查找某个元素属于哪个集合，可以用来确定两个元素是否在同一个集合中； - Union 用于合并两个不同的集合； ...
普林斯顿·算法·PART I：第一章Union-Find
qq_37356854的博客
02-27 319
动态联通性问题描述： 有N个元素，开始时我们让每一个元素肚子构成一个集合。然后按一定的顺序将属于同一组中的元素合并，构成新的集合。其间要反复查询某个元素在哪个集合中。如下所示： （1）Quick-Find 声明一个长度为N的数组id，数组中元素的值代表它所属组的编号。将数组中的元素初始化为每个元素的索引值，这样就表示开始时每个元素各自构成一个独立的集合。每次union(i,j)的时候就将所有组编...
并查集(Union-Find)算法全面详解
行走
06-25 5975
一、前言 在看一个算法题时，其中一种解法用到了并查集，并查集在《算法第四版——1.5案例研究： union-find 算法》中有讲解，这里按照自己的理解记录一下并查集。 二、用途 并查集用于判断连个点所在的集合是否属于同一个集合，若属于同一个集合但还未合并则将两个集合进行合并。同一个集合的意思是这两个点是连通的，直接相连或者通过其它点连通。 三、什么是并查集 并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在..
python中union_UnionFind（PYthon实现）
weixin_39626298的博客
12-16 365
UnionFind用于解决图的连通性问题，不需要给出具体路径的情况，可用来计算连通分支数参考链接：这两篇博客对于问题讲的非常好，本文只给出Python的实现代码，以供参考class Quick_Find:def __init__(self,N):self.count = Nself.ids = [i for i in range(self.count)]def connect(self,p,q):...
并查集(Union-Find)算法介绍
热门推荐
不忘初心，好好沉淀
06-12 23万+
本文主要介绍解决动态连通性一类问题的一种算法，使用到了一种叫做并查集的数据结构，称为Union-Find。 更多的信息可以参考Algorithms 一书的Section 1.5，实际上本文也就是基于它的一篇读后感吧。 原文中更多的是给出一些结论，我尝试给出一些思路上的过程，即为什么要使用这个方法，而不是别的什么方法。我觉得这个可能更加有意义一些，相比于记下一些结论。
并查集(Union-Find)算法详解
guoziqing506的博客
12-08 5万+
并查集（Union-Find）是解决动态连通性问题的一类非常高效的数据结构。本文中，我将尽我所能用最简单，最清晰的逻辑展示出并查集的构造过程，同时还将对其中的关键步骤给出相应的Python代码。动态连通性可以想象一张地图上有很多点，有些点之间是有道路相互联通的，而有些点则没有。如果我们现在要从点A走向点B，那么一个关键的问题就是判断我们能否从A走到B呢？换句话说，A和B是否是连通的。这是动态连通性最
UnionFind-2x2.pdf
11-28
**并查集(Union-Find)** 并查集是一种数据结构，主要用于处理一些不相交集合的合并与查询问题。它支持三个基本操作： 1. **MAKE-SET(x)**: 创建一个新的集合，仅包含元素x。这个操作在一开始时将每个元素置于自己...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值