数据结构——并查集

目录

1、等价关系和等价类

2、并查集实现中的权衡

2.1、快速FIND实现(Quick FIND)

2.2、快速UNION实现(Quick UNION)

2.2.1、快速UNION实现(慢FIND)
2.2.2、快速UNION实现(快FIND)
2.2.3、利用路径压缩来实现快速UNION

2.3、小结

正文

1、等价关系和等价类

  • 假定S是集合,它包含元素和定义在集合上的关系R。对于集合中的每一对元素a,b∈S,aRb要么为真,要么为假。如果aRb为真,则a与b 相关,否则为 不相关。如果一个关系满足以下三种性质,则关系是 等价关系
    1)自反性:对于任意元素a∈S,aRa为真。
    2)对称性:对于任意两个元素a,b∈S,如果aRb为真,那么bRa也为真。
    3)传递性:对于任意三个元素a,b,c∈S,如果aRb为真,bRc为真,那么aRc也为真。

  • 【 例子】:铁路连接是一种等价关系。因为任何位置都能连接它自身,所以它是自反的。如果城市a与城市b之间有个连接线,那么城市b也能连接城市a,所以它是对称的。如果城市a连接城市b且城市b连接城市c,那么城市a也能连接城市c。

  • 元素a∈S的 等价类 是S的一个子集,该子集包含所有与a 相关 的元素。 等价类 对集合S产生一个分割,S中的每个成员都属于一个 等价类 中,那么判断aRb是否为真,需要判断两者是否属于同一个 等价类 中。

  • 任意两个 等价类 的交集为空,所以 等价类 有时候也叫 并查集,包括以下三个基本操作:
    1)创建一个等价类(MAKESET(X):创建包含元素X的新集合)。
    2)查找等价类(FIND(X):返回包含元素X的集合)。
    3)合并等价类(UNION(X,Y):通过合并元素X和Y来产生新集合,同时删除包含X和Y的原集合)。

2、并查集实现中的权衡

  • 初始时,假设输入n个集合,每个集合仅有一个元素。这说明初始表示所有关系都是假的(自反性除外)。每个集合都有不同元素,因此 Si∩Sj=空

  • 为添加关系aRb,需要首先检查a和b是否已经 相关 。可以通过在a和b上执行 FIND 操作来验证,并判断它们是否属于同一个 等价类 中。如果不在,那么就执行 UNION 操作。该操作将包含a和b的两个等价类 合并 到一个新的等价类,即创建集合 Sk=Si∪Sj,同时删除集合Si和Sj。有以下两种方法实现 FIND/UNION操作
    1)快速FIND实现(也叫Quick FIND)。
    2)快速UNION实现(也叫Quick UNION)。

2.1、快速FIND实现(Quick FIND)

  • 可以使用数组来实现,如下图所示2-1所示,假定所有元素都是按0~n-1编号,元素0的集合是3,元素2的集合是5,以此类推。


    数据结构——并查集_第1张图片
    图2-1 数组实现Quick FIND
  • FIND操作便只需要O(1)时间。为了执行 UNION(a,b)(假定a在集合i,b在集合j中),需要扫描整个数组,并将所有i中元素转移到j中,这需要花费 O(n) 时间。在最坏情况下,n-1个并集操作序列需要的时间为 O(n^2 )。如果有O(n^2)个FIND操作,那么平均时间复杂度为 O(1)。如果FIND操作很少,那么该时间复杂度就是不可接受的。

2.2、快速UNION实现(Quick UNION)

2.2.1、快速UNION实现(慢FIND)
  • 当且仅当元素在同一个集合时,FIND 操作才返回相同的值。在表示并查集时,主要目标是为每一组赋予不同的集合。可以通过 来实现,因为每一个元素只有一个 根结点,可以使用它作为集合。

  • 通过数组实现,对于每个元素,将保存元素的 双亲结点,为了区分根结点,假定数组根结点的双亲结点与其相同。定义如下操作:
    1)MAKESET(X):创建一个新集合,它只包含一个元素X,并在数组中更新X的双亲结点为X。这就意味着X的根结点是X。如图2-2所示。

    图2-2 MAKESET(X)

    2)UNION(X,Y):合并包含X和Y的两个集合,用合并后的集合替换这两个集合,并在此数组中将X的双亲结点更新为Y。如图2-3所示。
    数据结构——并查集_第2张图片
    图2-3 UNION(X,Y)

    3)FIND(X):返回元素X所在的集合,持续查找X的集合直至达到树的根结点。如图2-4所示。
    数据结构——并查集_第3张图片
    图2-4 FIND(X)

  • 例子:对于元素0~6,初始表示如图2-5所示:

    数据结构——并查集_第4张图片
    图2-5 初始图

    1)执行完UNION(5,6)后,如图2-6所示:
    数据结构——并查集_第5张图片
    图2-6 UNION(5,6)

    2) 执行完UNION(1,2)后,如图2-7所示:
    数据结构——并查集_第6张图片
    图2-7 UNION(1,2)

    3) 执行完UNION(0,2)后,如图2-8所示:
    数据结构——并查集_第7张图片
    图2-8 UNION(0,2)

    【这里的一个要点是,UNION操作只改变根结点的双亲结点而不改变集合中其他元素的双亲结点。由此,UNION操作的时间复杂度为 O(1),FIND(X)操作的时间复杂度与X在该树中的深度成 正比。最坏情况下,FIND操作的运行时间是O(n),m个连续的FIND操作需要O(mn)】

  • 代码实现:

    /// 
    /// 快速UNION(慢FIND)
    /// 
    public class DisjointSet {
        /// 
        /// 集合
        /// 
        public int[] S { get; set; }

        /// 
        /// 集合中元素的个数
        /// 
        public int size { get; set; }

        /// 
        /// 初始化集合
        /// 
        /// 
        public void MAKESET(int size) {
            S = new int[size];
            for (int i = size-1; i >=0; i--) {
                S[i] = i;
            }
        }

        /// 
        /// FIND
        /// 
        /// 
        /// 
        public int FIND(int x) {
            if (!(x >= 0 && x < size)) {
                return -1;
            }
            if (S[x] == x) {
                return x;
            }
            else {
                return FIND(S[x]);
            }
        }

        /// 
        /// UNION
        /// 
        /// 
        /// 
        public void UNION(int root1,int root2) {
            if (FIND(root1) == FIND(root2)) {
                return;
            }
            if (!((root1 >= 0 && root1 < size) && (root2 >= 0 && root2 < size))) {
                return;
            }
            S[root1] = root2;
        }
    }
2.2.2、快速UNION实现(快FIND)
  • 上述方法的主要问题是,在最坏情况下会得到一棵斜树,并且时间复杂度为O(n),有以下两种方式改进。
    1)基于大小的UNION(也叫基于重量的UNION):使较小的树作为较大树的一棵子树。
    2)基于高度的UNION(也叫基于秩的UNION):使高度较小的树作为高度较大的一棵子树。
1)基于大小的UNION
  • 前面的表示中,对于每个元素i,若该元素是 根元素,则存储i。而本方法则 存储树的大小的负值(即,如果树的大小为3,则根结点元素需要在数组中存储-3)。假定包含一个元素的集合大小为1,且存储为-1。图2-8的例子,用该方法后的表示如图2-9所示。
    数据结构——并查集_第8张图片
    图2-9 基于大小的UNION
  • 代码实现:
        /// 
        /// UNION(基于大小)
        /// 
        /// 
        /// 
        public void UNIONBySize(int root1,int root2) {
            if (FIND(root1) == FIND(root2)) {
                return;
            }
            if (S[root2] < S[root1]) {
                S[root2] += S[root1];
                S[root1] = root2; 
            }
            else {
                S[root1] += S[root2];
                S[root2] = root1;
            }
        }
2)基于高度的UNION
  • 与基于大小的UNION类似,本方法 存储树的高度的负值,假定只有一个元素的树的高度为1。图2-8的例子,用该方法后的表示如图2-10所示。
    数据结构——并查集_第9张图片
    图2-10 基于高度的UNION
  • 代码实现:
        /// 
        /// UNION(基于高度)
        /// 
        /// 
        /// 
        public void UNIONByHeight(int root1,int root2) {
            if (FIND(root1) == FIND(root2)) {
                return;
            }
            if (S[root2] < S[root1]) {
                S[root1] = root2;
            }
            else {
                if (S[root2] == S[root1]) {
                    S[root1]--;
                }
                S[root2] = root1;
            }
        }
3)比较基于大小的UNION和基于高度的UNION
  • 使用基于大小的UNION,任意结点的高度永远不会大于logn,当由于UNION操作使其高度增加时,它被放置在至少是原来 2倍 大小的树中。即它的高度最多是以 logn 倍增加的。FIND操作的时间复杂度为 O(logn),m次连续执行该操作需要 O(mlogn) 的时间。
  • 如果对于两棵相同高度的树进行UNION操作,树的高度会比之前的 高度增加1,否则就等于 高度最大 的那个。这就使得n个结点的树的高度增长的倍数 大于O(logn),m次连续执行该操作仍然需要 O(mlogn) 的时间。
2.2.3、利用路径压缩来实现快速UNION
  • FIND操作遍历从当前结点到根结点路径的一系列结点,通过将这些结点的每个 父指针直接指向根结点,可以使后面的FIND操作更高效,这个过程叫做 路径压缩

  • 对FIND函数,使用路径压缩的唯一改变是S[X]的值等于FIND函数的返回值。通过递归地寻找该结点集合的根结点,然后令X直接指向根结点。如图2-11所示。


    数据结构——并查集_第10张图片
    图2-11 路径压缩
  • 代码实现:

        /// 
        /// 路径压缩FIND
        /// 
        /// 
        /// 
        public int FIND2(int x) {
            if (!(x >= 0 && x < size)) {
                return -1;
            }
            if (S[x] <= 0) {
                return x;
            }
            else {
                S[x] = FIND2(S[x]);
                return S[x];
            }
        }

注意:路径压缩与基于大小的UNION兼容,但与基于高度的UNINO不兼容,因为没有有效的方法来改变树的高度

2.3、小结

  • 在包含n个对象的集合中执行m次的UNION-FIND操作,最坏情况的时间复杂度如下所示。
算法 最坏情况时间
快速FIND mn
快速UNION mn
基于大小/高度的UNION n+mlogn
路径压缩 n+mlogn
基于大小的UNION+路径压缩 (n+m)logn

你可能感兴趣的:(数据结构——并查集)