并查集详解

什么是并查集？

并查集，一种特殊的数据结构（它的逻辑结构本质也是一颗“树”，有唯一的根节点，任意数的子节点），它的特殊在于它只定义了两种数据操作（查找和合并）。
通常用来解决连通性问题，
查询（find）：就是查找任意两个节点是否连通，就是是否有共同的祖先（节点找它的父节点的过程，一层一层地找）。
合并（union）：把两个不相交的集合合并为一个集合

实现

1.初始化
每个节点都是代表节点，独立存在
2.查找代表节点（find）
3.合并两个团伙
将小团伙挂载到大团伙上。

代码实现

package Union_Set;

//数组实现并查集
public  class UnionFind {
    // parent[i] = k ： i的父亲是k
    private int[] parent;
    // size[i] = k ： 如果i是代表节点，size[i]才有意义，否则无意义
    // i所在的集合大小是多少
    private int[] size;
    // 辅助结构,做栈使用
    private int[] help;
    // 一共有多少个集合
    private int sets;

    public UnionFind(int N) {
        parent = new int[N];
        size = new int[N];
        help = new int[N];
        sets = N;
        for (int i = 0; i < N; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }

    // 从i开始一直往上，往上到不能再往上，代表节点，返回
    // 这个过程要做路径压缩
    private int findFather(int i) {
        int hi = 0;
        while (i != parent[i]) {
            //记录经过的所有节点位置
            help[hi++] = i;
            i = parent[i];
        }
        //路径压缩过程，将路过节点的parent更新
        for (hi--; hi >= 0; hi--) {
            parent[help[hi]] = i;
        }
        return i;
    }

    public void union(int i, int j) {
        int f1 = findFather(i);
        int f2 = findFather(j);
        if (f1 != f2) {
            //将size小的集合，挂载在size更大的集合上。
            if (size[f1] >= size[f2]) {
                size[f1] += size[f2];
                parent[f2] = f1;
            } else {
                size[f2] += size[f1];
                parent[f1] = f2;
            }
            sets--;
        }
    }

    public int sets() {
        return sets;
    }
}

并查集问题应用

547. 省份数量
     https://leetcode-cn.com/problems/number-of-provinces/

class Solution {
    public int findCircleNum(int[][] isConnected) {
        int N = isConnected.length;
        UnionFind unionFind = new UnionFind(N);
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                if (isConnected[i][j] == 1) {
                    unionFind.union(i, j);
                }
            }
        }
        return unionFind.sets();
    }
    class UnionFind{
        private int[] parent;
        private int[] size;
        private int[] help;
        private int sets;

        public  UnionFind(int N){
            parent = new int[N];
            size = new int[N];
            help = new int[N];
            sets = N;
        for (int i = 0; i < N; i++) {
            parent[i] = i;
            size[i] = 1;
        }
        }

        private int findFather(int i){
            int hi=0;
            while(i!=parent[i]){
                help[hi++]=i;
                i=parent[i];
            }
            //路径压缩  
            for(hi--;hi>=0;hi--){
                parent[help[hi]]=i;
            }
            return i;
        }

        public void union(int i,int j){
            int f1= findFather(i);
            int f2=findFather(j);
            if(f1!=f2){
                if(size[f1]>=size[f2]){
                    size[f1]+=size[f2];
                    parent[f2]=f1;
                }else{
                    size[f2]+=size[f1];
                    parent[f1]=f2;
                }
                sets--;
            }
        }
        public int sets(){
            return sets;
        }

    }
}