算法导论总结索引 | 第五部分第二十一章：用于不相交集合的数据结构

Asher Gu

于 2024-08-02 22:09:01 发布

阅读量341

点赞数 6

分类专栏：算法导论文章标签：算法数据结构

本文链接：https://blog.csdn.net/AsherGu/article/details/140872434

版权

算法导论专栏收录该内容

21 篇文章 1 订阅

订阅专栏

一些应用涉及将n个不同的元素分成一组不相交的集合。寻找包含给定元素的唯一集合和合并两个集合

1、不相交集合的操作

1、一个不相交集合数据结构维持了一个不相交动态集的集合 S = {S_1, S_2,…, S_n}。用一个代表来标识每个集合，它是这个集合的某个成员。在一些应用中，不关心哪个成员被用来作为代表，仅仅关心的是重复两次查询动态集合的代表中，如果这两次查询没有修改动态集合，则两次查询应该得到相同的结果。其他一些应用可能会需要一个预先说好的规则来选择代表，比如选择这个集合中最小的成员

2、用一个对象表示一个集合的每个元素。设 x 表示一个对象，希望支持以下三个操作：

MAKE-SET(x): 建立一个新的集合，它的唯一成员 (因而为代表) 是 x。因为各个集合是不相交的，故 x 不会出现在别的某个集合中
UNION(x, y): 将包含 x 和 y 的两个动态集合 (分别表示为S_x和S_y) 合成一个新的集合，即这两个集合的并集。虽然 UNION 的很多实现中特别地选择 S_x 或 S_y 的代表作为新的代表，然而结果集的代表可以是S_x∪S_y 的任何成员。由于要求各个集合不相交，故要 “消除” 原有的集合 S_x 和 S_y，即将它们从 S 中删除。实际上，经常把其中一个集合的元素并入另一个集合中，来代替删除操作
FIND-SET(x): 返回一个指针，这个指针指向包含 x 的(唯一)集合的代表

使用两个参数来分析不相交集合数据结构的运行时间: 一个参数是 n，表示 MAKES-SET 操作的次数；另一个是m，表示 MAKE-SET、UNION 和 FIND-SET 操作的总次数

每个 UNION 操作减少一个集合，因此，n - 1 次 UNION 操作后，只有一个集合留了下来。也就是说，UNION 操作的次数至多是 n - 1。由于 MAKE-SET 操作被包含在总操作次数 m 中，因此有 m ≥ n。假定 n 个 MAKE-SET 操作总是最先执行

1.1 不相交集合数据结构的一个应用

确定无向图的连通分量

下面的 CONNECTED-COMPONENTS 过程使用不相交集合操作计算一个图的连通分量。一旦 SAME-COMPONENTS 预处理了该图，过程 SAME-COMPONENT 就回答两个顶点是否在同一个连通分量的询问（图G的顶点集用 G.V 表示，边集用 G.E 表示）

图21-1(b)展示了 CONNECTED-COMPONENTS 如何计算不相交集合
在这里插入图片描述

CONNECTED-COMPONENTS(G)
1 for each vertex v ∈ G.V
2 	MAKE-SET(v)
3 for each edge (u, v) ∈ G.E
4 	if FIND-SET(u) ≠ FIND-SET(v)
5 		UNION(u, v)

SAME-COMPONENT(u,v)
1 if FIND-SET(u) == FIND-SET(v)
2 	return TRUE
3 else return FALSE

处理完所有的边之后，两个顶点在相同的连通分量当且仅当与之对应的对象在相同的集合中
一个表示顶点的对象会包含一个指向与之对应的不相交集合对象的指针

在这里插入图片描述

2、不相交集合的链表表示

实现不相交集合数据结构的简单方法：每个集合用一个自己的链表来表示。每个集合的对象包含 head 属性和 tail 属性；head 属性指向链表的第一个对象，tail 属性指向链表的最后一个对象。链表中的每个对象都包含一个集合成员，一个指向链表中下一个对象的指针和一个指回到集合对象的指针。在每个链表中，对象可以以任意的次序出现。代表是链表中第一个对象的集合成员

MAKE-SET 操作和 FIND-SET 操作是非常方便的，只需 O(1) 的时间

要执行 MAKE-SET(x) 操作，需要创建一个只有 x 对象的新链表。对于 FIND-SET(x)，仅沿着指针 x 对象的返回指针返回到集合对象，然后返回 head 指向对象的成员
在这里插入图片描述

2.1 合并的一个简单实现

UNION 操作通过把 y 所在的链表拼接到 x 所在的链表实现了 UNION (x, y)。x 所在的链表的代表成为结果集的代表。利用 x 所在链表的 tail 指针，可以迅速地找到拼接 y 所在的链表的位置

对于 y 所在链表的每个对象，必须更新指向集合对象的指针，这将花费的时间与 y 所在链表长度呈线性关系

构建一个在 n 个对象上需要 Θ(n²) 时间的 m 个操作序列。假设有对象 x1, x2, …, xm，执行 n 个 MAKE-SET 操作，后面跟着 n-1 个 UNION 操作。因而有 m = 2n - 1。执行 n 个 MAKE-SET 操作需要 Θ(n) 时间。由于第 i 个 UNION 操作更新 i 个对象（参数中右侧插在左侧的集合后面）
在这里插入图片描述

因此所有的 n-1 个 UNION 操作更新的对象的总数为：
在这里插入图片描述
总的操作数为 2n-1，这样每个操作平均需要 Θ(n) 的时间。也就是说，一个操作的摊还时间为 Θ(n)

2.2 一种加权合并的启发式策略

1、在最坏情况下，上面给出的 UNION 过程的每次调用平均需要 Θ(n) 的时间，这是因为需要把一个较长的表接到一个较短的表上，此时必须对较长表的每个成员更新其指向集合对象的指针

加权合并启发式策略：假使表中包含了表的长度（易于维护）以及拼接次序可以任意的话，总是把较短的链表拼接到较长的表中

2、使用不相交集合的链表表示加权合并启发式策略，一个具有 m 个 MAKE-SET, UNION 和 FIND-SET 操作的序列（其中有 n 个是 MAKE-SET 操作）需要的时间为 O(m + nlg n)

证明：由于每个UNION操作合并两个不相交集，因此总共至多执行 n-1 个UNION操作。现在来确定由这些 UNION 操作所花费时间的上界。首先确定每个对象指向它的集合对象的指针被更新次数的上界。每次 x 的指针被更新，x 一定先在一个规模较小的集合中。因此，第一次 x 的指针被更新时，结果集一定至少有 2 个成员，类似地，下次 x 的指针被更新时结果集至少有4个成员。一直继续下去，注意到对于任意的 k ≤ n，在 x 的指针被更新 ⌈lg k⌉ 次后，结果集一定至少有 k 个成员。因为最大集合至多包含 n 个成员，所以每个对象的指针在所有的 UNION 操作中最多被更新 ⌈lg n⌉ 次。当然，也必须考虑 tail 指针和表长度的更新，而它们在每个 UNION 操作中只花费 Θ(1) 时间。所以总共花在 UNION 操作上的时间为 O(nlg n)

每个 MAKE-SET 和 FIND-SET 操作需要 O(1) 时间，它们的总数为 O(m)。所以整个序列的总时间是 O(m+nlg n)

3、使用链表表示和加权合并启发式策略，写出 MAKE-SET、FIND-SET 和 UNION 操作的伪代码，并指定在集合对象和表对象中所使用的属性

MAKE-SET(x)
// Assume x is a pointer to a node contains .key .set .next
    Create a node S contains .head .tail .size
    x.set = S
    x.next = NIL
    S.head = x
    S.tail = x
    S.size = 1
    return S

FIND-SET(x)
    return x.set.head

UNION(x, y)
    S1 = x.set
    S2 = y.set
    if S1.size >= S2.size
        S1.tail.next = S2.head
        z = S2.head
        while z != NIL // 把S2中所有元素都改成S1的
            z.set = S1
            z = z.next
        S1.tail = S2.tail
        S1.size = S1.size + S2.size // Update the size of set
        return S1
    else
        same procedure as above
        change x to y
        change S1 to S2

在这里插入图片描述

3、不相交集合森林

在一个不相交集合更快的实现中，使用有根树来表示集合，树中的每个节点包含一个成员，每棵树代表一个集合。在一个不相交集合森林中（如图所示），每个成员仅指向它的父结点，每棵树的根节点包含集合的代表。每个树中的每个成员都是它所在集合的成员，同时其根节点表示该集合的代表，并且是指向代表的根节点。我们可以在树根节点中做任何操作来执行FIND-SET，虽然树根节点可能处于集合森林的不同位置，但是结果总是同样的成员代表。随着进一步的优化和策略“按秩合并”（union by rank），我们能得到一个渐近更优的不相交集合数据结构

MAKE-SET 操作简单地创建一棵只有一个结点的树，FIND-SET 操作通过沿着指向父结点的指针找到树的根。这一通向根结点的简单路径上所访问的结点构成了查找路径。UNION 操作使得一棵树的根指向另外一棵树的根
在这里插入图片描述

3.1 改进运行时间的启发式策略

第一种启发式策略是按秩合并，它类似于链表表示中使用的加权合并启发式策略。使具有较少节点的树的根指向具有较多的树的根。不显式地记录每个结点为根的子树的大小，而是采用一种易于分析的方法。对于每个结点，维护一个秩，该秩表示该结点高度的一上界。使用按秩合并策略的 UNION 操作中，可以让具有较小秩的根指向具有较大秩的根

第二种启发式策略是路径压缩，在 FIND-SET 操作中，使用这种策略可以使查找路径中的每个结点直接指向根。路径压缩并不改变任何结点的秩

注意三角形是一棵树，而不是结点
在这里插入图片描述

3.2 实现不相交集合森林的伪代码

为了使用按秩合并的启发式策略实现一个不相交集合森林，必须记录下秩的变化情况。对于每个结点 x，维护一个整数值 x.rank，它代表 x 的高度 (从 x 到某一后代叶结点的最长简单路径上边的数量) 的一个上界。当 MAKE-SET 创建一个单元素集合时，这个树上的单结点有一个为0的初始秩。每一个 FIND-SET 操作不改变任何秩

UNION 操作有两种情况，取决于两棵树的根是否有相同的秩。如果根没有相同的秩，就让较大秩的根成为较小秩的根的父结点（因为 FIND-SET 复杂度是高度），但秩本身保持不变。另一种情况是两个根有相同的秩时，任意选择两个根中的一个作为父结点，并使它的秩加1

用 x.p 代表结点 x 的父结点

MAKESET(x)
1	x.p = x
2	x.rank = 0

UNION(x, y)
1   LINK(FIND-SET(x), FIND-SET(y))

LINK(x, y)
1   if x.rank > y.rank
2      y.p = x
3   else x.p = y
4      if x.rank == y.rank
5         y.rank = y.rank + 1

带有路径压缩的 FIND-SET 过程

FIND-SET(x)
1   if x != x.p
2      x.p = FIND-SET(x.p) // 使 x 到根路径上的所有结点的父结点 为根结点
3   return x.p

FIND-SET 过程是一种两趟方法：当它递归时，第一趟沿着查找路径向上直到找到根，当递归回溯时，第二趟沿着搜索树向下更新到结点 x 路径中的每个结点，使其直接指向根。FIND-SET(x) 的每次调用在第3行返回 x.p

如果 x 是根，那么 FIND-SET 跳过第2行并返回 x.p，也就是x，这是递归到原点的情形。否则，第2行执行，并且参数为 x.p 的递归调用返回一个指向根的指针。第2行更新结点 x 并让其直接指向根结点，然后第3行返回这个指针

3.3 启发式策略对运行时间的影响

单独使用按秩合并或路径压缩，每个都能改善不相交集合森林上操作的运行时间，而两者结合在一起效果更好。单独来看，路径压缩产生的运行时间上限为 O(m lg n)，并且这是个界是紧确的

对于一个具有 n 个 MAKE-SET 操作（因此最多有 n-1 个UNION操作）和 f 个 FIND-SET 操作的操作序列，单独使用路径压缩启发式策略的最坏情况下的运行时间为 Θ(n+ f*(1 + log(2+f/n)n))

当同时使用按秩合并与路径压缩时，最坏情况下的运行时间为 O(mα(n))，这里 α(n) 是一个增长非常慢的函数，在任何一个可以想到的不相交集合数据结构的应用中，α(n) 都 ≤ 4

21.3-1 用按秩合并与路径压缩启发式策略的不相交集合森林完成

1 for i = 1 to 16
2 	MAKE-SET(x_i)
3 for i = 1 to 15 by 2
4 	UNION(x_i, x_{i+1})
5 for i = 1 to 13 by 4
6 	UNION(x_i, x_{i+2})
7 UNION(x_1, x_5)
8 UNION(x_9, x_13)
9 UNION(x_1, x_9)