并查集

算法学习笔记 : 并查集

并查集主要用于解决一些元素分组的问题，它管理一系列不相交的集合，并支持两种操作：

• 合并(Union): 把两个不想交的集合合并为一个集合。
• 查询(Find): 查询两个元素是否在同一个集合中。

并查集的引入

并查集的重要思想在于，用集合中的一个元素代表集合。我曾看过一个有趣的比喻，把集合比喻成帮派，而代表元素则是帮主。接下来我们利用这个比喻，看看并查集是如何运作的。

最开始，所有大侠各自为战。他们各自的帮主自然就是自己，(对于只有一个元素的集合，代表元素自然是唯一的那个元素)。
现在1号和3号比武，假设1号赢了(这里具体谁赢暂时不重要)，那么3号就认1号作帮主(合并1号和3号所在的集合，1号为代表元素)。

现在2号想和3号比武(合并3号和2号所在的集合)，但3号表示，别跟我打，让我帮主来收拾你(合并代表元素)。不妨设置这次有是1号赢了，那么2号也认1号做帮主。

现在我们假设4,5,6号也要进行了一番帮派合并，江湖局势变成下面这样：

现在假设2号想与6号比，根刚才说得一样，喊帮主1号和4号出来打一架(帮主真辛苦啊)。1号胜利后，4号认1号为帮主，当然他的手下也跟着都投降了。

好了，比喻结束了。如果你有一点图论基础，相信你已经察觉到，这是一个树状的结构，要寻找集合的代表元素，只需要一层一层往上访问父节点(图中箭头所指的圆)，直达树的根节点(图中橙色的圆)即可。根节点的父节点是它自己。我们可以直接把它画成一棵树：

用这个方法，我们可以写出最简单版本的并查集代码。

初始化

class UnionSet{
    constructor(n) {
        // 并查集里面所有节点的父亲节点都是它自己
        this.parent = new Array(n).fill(0).map((value, index) => index);
    }
}

假如有编号为1,2,3,4,...,n的n个元素，我们用一个数组parent[]来存储每个元素的父节点(因为每个元素有且只有一个父节点，所以这是可行的)。一开始，我们先将它们的父节点设为自己。

查询

find(x) {
    if(this.parent[x] == x) return;
    return this.find(this.parent[x]);
}

我们用递归的写法实现对代表元素的查询：一层一层访问父节点，直至根节点(根节点的标志就是父节点是本身)。要判断两个元素是否属于同一个集合，只需要看它们的节点是否相同即可。

合并

merge(a, b){
    this.parent[this.find(a)] = this.find(b);
}

合并操作也是很简单的，先找到两个集合的代表元素，然后将前者的父节点设为后者即可，当然也可以将后者的父节点设为前者。这里暂时不深入讨论，本文末尾会给出一个更合理的合并方法。

路径压缩

最简单的并查集效率是比较低的。例如，来看下面这个场景：

现在我们要merge(2, 3),于是从2找到1，parent[1] = 3,于是变成了这样：

然后我们又找来了一个元素4，并需要执行merge(2, 4):

从2找到1，再找到3，然后parent[3] = 4,于是变成了这样：

大家应该有感觉了，这样可能会形成一条长长的链，随着链越来越长，我们想要从底部找到根节点，会变得越来越难。 怎么解决呢？我们可以使用路径压缩的方法。既然我们只关心一个元素对应的根节点，那我们希望每个元素到根节点的路径尽可能短，最好只需要一步，像这样：

其实这说来也很好实现。只要我们在查询的过程中，把沿途的每个节点的父节点都设置为根节点即可。下一次查询时，我们就可以省很多事。这用递归的写法很容易实现：

合并(路径压缩)

find(x) {
    if(this.parent[x] == x) return x;
    // 递归找到根节点
    let root = this.find(this.parent[x]);
    // 直接把当前节点挂载到根节点上
    this.parent[x] = root;
    // 返回最新的根节点
    return root;
}

以上代码常常简写为一行：

    return this.parent[x] = this.parent[x] == x ? x : this.find(this.parent[x]);
}

路径压缩优化后，并查集的时间复杂度已经比较低了，绝大多数不相交集合的并查集查询问题能够解决。然而，对于某些时间卡的很紧的题目，我们还需要进一步优化。

按秩优化

有些人可能有一个误解，以为路径压缩优化后，并查集始终都是一个菊花图(只有两层的树的俗称)。但其实，由于路径压缩只在查询时进行，也只压缩一条路径，所以并查集最终的结构仍然可能比较复杂。例如，现在我们有一颗较复杂的树需要与一个单元素的集合合并：

假如这时我们要merge(7, 8),如果我们可以选择的话，是把7的父节点设为8好，还是把8的父节点设为7好呢？
当然是后者，因为如果把7的父节点设为8，会使树的深度(树中最长链的长度)加深，原来的树中每个元素到根节点的距离都变长了，之后我们寻找根节点的路径也会相应变长。虽然我们有路径压缩，但路径压缩也是会消耗时间的。而把8的父节点设为7，则不会有这个问题，因为它没有影响到不相关的节点。

这启发我们：我们应该把简单的树往复杂的树上合并，而不是相反。因为这样合并后，到根节点距离变长的节点个数比较少。

初始化(按秩优化)

class UnionSet{
    constructor(n) {
        this.parent = new Array(n).fill(0).map((value, index) => index);
        this.rank = new Array(n).fill(1);
    }
}

合并(按秩合并)

merge(a, b) {
    let ra = this.find(a), rb = this.find(b);
    if(ra == rb) return ;
    if(this.rank[ra] < this.rank[rb]) {
        this.parent[ra] = rb;
        this.rank[rb] += this.rank[ra];
    } else {
        this.parent[rb] = ra;
        this.rank[ra] += this.rank[rb];
    }
    return ;
}

最终的并查集代码模板

class UnionSet{
    constructor(n) {
        this.parent = new Array(n).fill(0).map((value, index) => index);
    }
    get(x){
        return this.parent[x] = (this.parent[x] == x ? x : this.get(this.parent[x]));
    }
    merge(a, b){
        if(this.get(a) == this.get(b)) return;
        const root = this.get(a);
        this.parent[this.get(b)] = root;
    }
}

参考文章