union-find算法

在《算法》第4版中，union-find是第一章最后的一个算法介绍，也叫做并查集，在维基百科中是这样解释并查集的：在计算机科学中，并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（union-find algorithm）定义了两个用于此数据结构的操作：

• Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
• Union：将两个子集合并成同一个集合。

说了这么一大堆，其实就是相当于垃圾分类？只不过这些“垃圾”之间有一些联系，将这些有联系的“垃圾”分在一起，构成一个个“垃圾堆”，而这个算法就是将“垃圾”进行分类的过程。而书中所说的分量就是一个个的”垃圾堆“。最开始每一个垃圾都是一个“垃圾堆”，因此最开始有N个分量，然后根据两两之间的联系，两个“垃圾堆”组成一个更大的“垃圾堆”。而实际中应用就类似QQ里面的共同好友推荐中找到共同好友的算法吧。

下面给出书中的代码：

顺便给出algs4.jar包，这个包是书的作者封装好的一些方法。

这个链接里面有algs4.jar包 https://blog.csdn.net/weixin_44292560/article/details/105566825

首先是书中的第一种方法：

/**
 * @Author: 商火
 * @Date: 2020/4/16 19:05
 * @Description:
 */
public class UF{
    private int[] id;   // 分量id(以触点作为索引）---垃圾（一开始每个垃圾都是一个垃圾堆）
    private int count;  // 分量数量---垃圾堆

    public UF(int N){
        count = N;	
        id = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
        }
    }

    public int count(){
        return count;
    }

    public boolean connected(int p,int q){
        return find(p) == find(q);
    }


    public int find(int p) {
        return id[p];
    }



    public void union(int p,int q){
        //将p,q归并到相同的分量（垃圾堆）中
        int pID = find(p);
        int qID = find(q);

        //如果q和p已经在相同的分量（垃圾堆）之中则不需要采取任何行动
        if(qID == qID){
            return;
        }

        //将 p的分量重命名为q的名称---合并垃圾堆
        for(int i=0;i<id.length;i++){
            if(id[i]==pID){
                id[i] = qID;
            }
        }
        count--;
    }
}

其实弄懂了这个算法是要做什么，理解代码反而变得简单了。

现在看这个算法不免觉得它有点复杂了，每一个“垃圾”都要遍历全部的“垃圾”找到与之在同一个“垃圾堆”（分量），然后归并。而实际上，我们只需要对两个分量（垃圾堆）进行归并，而不是一个一个垃圾的进行归并，在这里，我们将每一个垃圾堆看作一个集合（其实这是有问题的，后面我会说到），每次归并只需要判断p垃圾堆中的垃圾是否和q垃圾堆中的垃圾有联系，如果有联系，就将p垃圾堆和q垃圾堆归并，成为一个大的垃圾堆，而这时这个大垃圾的id可能是由p融入q，也可能是由q融入p，而这两个是有区别的。

这里只给出有变化的两个方法代码：

public int find(int p) {
        while(p!=id[p]) p = id[p];
        return p;
    }

public void union(int p,int q){
    //将q和p根节点统一
    int pRoot = find(p);
    int qRoot = find(q);
    if(qRoot == pRoot)	return;
    id[pRoot] = qRoot;
    count--;
}

关于上面这个方法一开始我想到的就是这种，但是我并没有把它当作一棵树，而是一个集合，因为宏观上两个分量（垃圾堆）的归并的就是两个集合的合并，但实际上这个归并的过程是有深度的，而这树的深度也决定了方法的效率，这也是我前面说将它看出集合是有问题的原因。

而方法三就是对方法二的改进，在方法二的基础上添加权重的属性，使小的树融入大的树（遍历的深度更浅），而不是反过来，这也是前面我所说的区别。

下面给出代码：

/**
 * @Author: 商火
 * @Date: 2020/4/16 19:05
 */
public class WeightedQuickUnionUF {
    private int[] id;   // 分量id(以触点作为索引）
    private int[] sz;   //各个根节点所对应的分量的大小
    private int count;  // 分量数量

    public WeightedQuickUnionUF(int N){
        count = N;
        id = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
            sz[i] = 1;
        }
    }

    public int count(){
        return count;
    }

    public boolean connected(int p,int q){
        return find(p) == find(q);
    }

    private int find(int p){
        while (p!=id[p]) p = id[p];
        return p;
    }

    public void union(int p,int q){
        int i = find(p);
        int j = find(q);
        if(i ==j) return;

        //将小叔的根节点连接到大树的根节点
        if(sz[i]<sz[j]){
            id[i] = j;
            sz[j]+=sz[i];
        }else{
            id[j] = i;
            sz[i]+=sz[j];
        }
        count--;
    }
}