Union－Find 并查集

主要解决连通问题。

Test Case

public class UF_Test {
    static int[][] connection = { {4, 3}, {3, 8}, {6, 5}, {9, 4}, {2, 1} };
    public static void main(String[] args) {
        UF uf = new UF(10);
        for(int i = 0; i < connection.length; i++) {
            uf.union(connection[i][0], connection[i][1]);
        }
        System.out.println(uf.connected(0, 7));
    }
}

1. Quick－Find

public class UF {
    int id[]; //id[]存储每个节点所属的等价类的编号

    //初始化时每个节点属于不同的等价类
    public UF(int n) {
        id = new int[n];
        for(int i = 0; i < n; i++) 
            id[i] = i;
    }

    //如果两个节点属于同一个等价类，则连通
    public boolean connected(int p, int q) {
        return id[p] == id[q] ? true : false;
    }

    //连接两个节点时，将节点p所在的等价类合并到q所在的等价类中
    public void union(int p, int q) {
        if(id[p] == id[q])
            return;
        for(int i = 0; i < id.length; i++) {
            if(id[i] == id[p]) 
                id[i] = id[q];
        }
    }
}

时间复杂度：m*n

2. Quick-Union

public class UF {
    int id[];
    public UF(int n) {
        id = new int[n];
        for(int i = 0; i < n; i++) 
            id[i] = i;
    }
    //每个等价类为一棵树。若两个节点的根节点相同，则连通
    public boolean connected(int p, int q) {
        return root(p) == root(q) ? true : false;
    }
    //将节点p的根节点指向节点q的根节点
    public void union(int p, int q) {
        id[root(p)] = root(q);
    }
    //寻找节点p的根节点
    public int root(int p) {
        while(p != id[p]) {
            p = id[p];
        }
        return p;
    }
}

树的高度有可能很高。这样在最坏情况下，root方法的时间复杂度为n，整个时间复杂度变为m*n

3. Refined Quick-Union

思想：优化union方法和root方法，使得树的高度最终为1。

public class UF {
    int id[];
    int size[];//size[i]记录了以节点i为根的树中所含的节点个数
    public UF(int n) {
        id = new int[n];
        size = new int[n];
        for(int i = 0; i < n; i++) 
            id[i] = i;
    }
    public boolean connected(int p, int q) {
        return root(p) == root(q) ? true : false;
    }
    //将size较小的节点的根节点指向size较大的节点的根节点
    public void union(int p, int q) {
        if(size[p] < size[q])
            id[root(p)] = root(q);
        else
            id[root(q)] = root(p);
    }
    public int root(int p) {
        while(p != id[p]) {
            id[p] = id[id[p]]; //将该节点往上移一层
            p = id[p];
        }
        return p;
    }
}

时间复杂度：m*lgn