目录

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，以此类推。

  
  
  图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-3 UNION(X,Y)
  
  3）FIND(X)：返回元素X所在的集合，持续查找X的集合直至达到树的根结点。如图2-4所示。
  
  图2-4 FIND(X)

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

  图2-5 初始图
  
  1）执行完UNION(5,6)后，如图2-6所示：
  
  图2-6 UNION(5,6)
  
  2） 执行完UNION(1,2)后，如图2-7所示：
  
  图2-7 UNION(1,2)
  
  3） 执行完UNION(0,2)后，如图2-8所示：
  
  图2-8 UNION(0,2)
  
  【这里的一个要点是，UNION操作只改变根结点的双亲结点而不改变集合中其他元素的双亲结点。由此，UNION操作的时间复杂度为 O(1)，FIND(X)操作的时间复杂度与X在该树中的深度成 正比。最坏情况下，FIND操作的运行时间是O(n)，m个连续的FIND操作需要O(mn)】

• 代码实现：

    /// <summary>
    /// 快速UNION（慢FIND）
    /// </summary>
    public class DisjointSet {
        /// <summary>
        /// 集合
        /// </summary>
        public int[] S { get; set; }

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

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

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

        /// <summary>
        /// UNION
        /// </summary>
        /// <param name="root1"></param>
        /// <param name="root2"></param>
        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所示。
  
  图2-9 基于大小的UNION
• 代码实现：

        /// <summary>
        /// UNION（基于大小）
        /// </summary>
        /// <param name="root1"></param>
        /// <param name="root2"></param>
        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所示。
  
  图2-10 基于高度的UNION
• 代码实现：

        /// <summary>
        /// UNION（基于高度）
        /// </summary>
        /// <param name="root1"></param>
        /// <param name="root2"></param>
        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所示。

  
  
  图2-11 路径压缩

• 代码实现：

        /// <summary>
        /// 路径压缩FIND
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        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操作，最坏情况的时间复杂度如下所示。