并查集

并查集

先给出并查集接口(具体做算法题的时候可以不用定义)

package com.ffyc.algorithm.并查集;

public interface UF {
    //获取并查集分组数目
    int getSize();
    //合并
    void union(int p, int q);
    //判断是否连接
    boolean isConnected(int p ,int q);
}

最原始的并查集 : 基于集合(数组)实现

package com.ffyc.algorithm.并查集;

/**
 * 最原始的并查集 ---> 都不是基于树结构的
 */
public class UnionFind implements UF{
    private int [] ids;
    public UnionFind(int size) {
        ids = new int[size];
        for(int i = 0; i < size; i++) {
            ids[i] = i;
        }
    }
    @Override
    public int getSize() {
        return ids.length;
    }

    //定义一个辅助方法
    public int getIds(int index) {
        return ids[index];
    }

    @Override
    public void union(int p, int q) {
        int pId = getIds(p);
        int qId = getIds(q);
        if(pId != qId) {
            for(int i = 0; i < ids.length; i++) {
                if(getIds(i) == pId) {
                    ids[i] = qId;
                }
            }
        }
    }

    @Override
    public boolean isConnected(int p, int q) {
        return getIds(p) == getIds(q);
    }
}

基于多叉树(树结构)实现的并查集 :

package com.ffyc.algorithm.并查集;

/**
 * 对于最原始并查集的优化 --> 改为了树结构存储
 */
public class UnionFindPlus implements UF{
    private int [] parents;
    //维护并查集中分组的个数
    private int count;
    public UnionFindPlus(int size){
        parents = new int[size];
        for(int i = 0; i < size; i++) {
            parents[i] = i;
            count++;
        }
    }
    @Override
    public int getSize() {
        return this.count;
    }

    //定义一个辅助方法 --> 寻找根节点
    public int getParent(int index){
        if(index == parents[index]) {
            return index;
        }
        return getParent(parents[index]);
    }
    @Override
    public void union(int p, int q) {
        int pParent = getParent(p);
        int qParent = getParent(q);
        if(pParent != qParent) {
            parents[pParent] = qParent;
        }
    }

    @Override
    public boolean isConnected(int p, int q) {
        return getParent(p) == getParent(q);
    }
}

基于size做一个优化:

size是指某个子树上结点的个数

package com.ffyc.algorithm.并查集;

/**
 * 基于Size优化的并查集
 */
public class UnionFindSZ implements UF{
    private int [] parents;
    //记录一个当前节点为根节点的子树的高度
    private int [] sz;
    //维护并查集中的分组数目
    private int count;
    public UnionFindSZ(int size){
        parents = new int[size];
        sz = new int[size];
        for(int i = 0; i < size; i++) {
            count++;
            parents[i] = i;
        }
        //初始的时候所有结点都是一个树, 所以开始的时候每个树的结点个数都是1
        for(int i = 0; i < size; i++){
            sz[i] = 1;
        }
    }
    @Override
    public int getSize() {
        return this.count;
    }

    /*
    在寻找父节点的时候完成路径压缩
     */
    //定义一个辅助方法 --> 寻找根节点
    public int getParent(int index){
        if(index == parents[index]) {
            return index;
        }
        return getParent(parents[index]);
    }

    //注意: 我们路径压缩的时候合并的时候是不需要变化的
    @Override
    public void union(int p, int q) {
        int pParent = getParent(p);
        int qParent = getParent(q);
        if(pParent != qParent) {
            //判断一下p结点的根节点的子树上的元素多还是q结点根节点为子树的结点多
            if(sz[pParent] > sz[qParent]) {
                //q结点的元素少, 所以让qparent指向pparent
                parents[qParent] = pParent;
                //不要忘记维护sz
                sz[pParent] += sz[qParent];
            }else {
                parents[pParent] = qParent;
                sz[qParent] += sz[pParent];
            }
            count--;
        }
    }

    @Override
    public boolean isConnected(int p, int q) {
        return getParent(p) == getParent(q);
    }
}

• 但是其实我们是要高度低, 而结点数量并不一定就反映了树的高度

基于某个子树高度rank的优化:

package com.ffyc.algorithm.并查集;

/**
 * 基于rank优化的并查集
 */
public class UnionFindRank implements UF{
    private int [] parents;
    //记录一个当前节点为根节点的子树上有多少个结点
    private int [] rank;
    //记录并查集中分组的个数
    private int count;
    public UnionFindRank(int size){
        parents = new int[size];
        rank = new int[size];
        for(int i = 0; i < size; i++) {
            count++;
            parents[i] = i;
        }
        //初始的时候所有结点都是一个树, 所以开始的时候每个树的结点个数都是1
        for(int i = 0; i < size; i++){
            rank[i] = 1;
        }
    }
    @Override
    public int getSize() {
        return this.count;
    }

    //定义一个辅助方法 --> 寻找根节点
    public int getParent(int index){
        if(index == parents[index]) {
            return index;
        }
        return getParent(parents[index]);
    }
    @Override
    public void union(int p, int q) {
        int pParent = getParent(p);
        int qParent = getParent(q);
        if(pParent != qParent) {
            //判断一下p结点的根节点的子树上的元素多还是q结点根节点为子树的结点多
            if(rank[pParent] > rank[qParent]) {
                //q结点的元素少, 所以让qparent指向pparent
                parents[qParent] = pParent;
            }else if(rank[pParent] < rank[qParent]){
                parents[pParent] = qParent;
            }else if(rank[pParent] == rank[qParent]) {
                parents[pParent] = qParent;
                rank[qParent]++;
            }
            count--;
        }
    }

    @Override
    public boolean isConnected(int p, int q) {
        return getParent(p) == getParent(q);
    }
}

基于Rank的路径压缩(分多次压缩, 一次压一点):

package com.ffyc.algorithm.并查集;

/**
 * 分压缩 （基于rank） --》 rank（等级，高度）
 */
public class UnionFindPC implements UF{
    private int [] parents;
    //记录一个当前节点为根节点的子树的高度
    private int [] rank;
    //维护并查集中的分组数目
    private int count;
    public UnionFindPC(int size){
        parents = new int[size];
        rank = new int[size];
        for(int i = 0; i < size; i++) {
            count++;
            parents[i] = i;
        }
        //初始的时候所有结点都是一个树, 所以开始的时候每个树的结点个数都是1
        for(int i = 0; i < size; i++){
            rank[i] = 1;
        }
    }
    @Override
    public int getSize() {
        return this.count;
    }

    /*
    在寻找父节点的时候完成路径压缩
     */
    //定义一个辅助方法 --> 寻找根节点
    public int getParent(int index){
        if(index == parents[index]) {
            return index;
        }
        //让当前节点的父节点指向当前节点父节点的父节点 --> 这里是不会出现越界的, 因为最终的时候根节点是指向自己的, 所以是一个环, 并不会影响正确性
        parents[index] = parents[parents[index]];
        return getParent(parents[index]);
    }

    //注意: 我们路径压缩的时候合并的时候是不需要变化的
    @Override
    public void union(int p, int q) {
        int pParent = getParent(p);
        int qParent = getParent(q);
        if(pParent != qParent) {
            //判断一下p结点的根节点的子树上的元素多还是q结点根节点为子树的结点多
            if(rank[pParent] > rank[qParent]) {
                //q结点的元素少, 所以让qparent指向pparent
                parents[qParent] = pParent;
            }else if(rank[pParent] < rank[qParent]){
                parents[pParent] = qParent;
            }else if(rank[pParent] == rank[qParent]) {
                parents[pParent] = qParent;
                rank[qParent]++;
            }
            count--;
        }
    }

    @Override
    public boolean isConnected(int p, int q) {
        return getParent(p) == getParent(q);
    }
}

基于Rank的路径压缩(全压缩, 一次直接压缩到根节点):

package com.ffyc.algorithm.并查集;

/**
 * 全压缩 （基于rank） --》 rank（等级，高度）
 */
public class UnionFindPCPlus implements UF{
    private int [] parents;
    //记录每个子树的高度
    private int [] rank;
    //维护并查集中分组的个数
    private int count;
    public UnionFindPCPlus(int size){
        parents = new int[size];
        rank = new int[size];
        for(int i = 0; i < size; i++) {
            parents[i] = i;
            count++;
        }
        //初始的时候所有结点都是一个树, 所以开始的时候每个树的高度都是1
        for(int i = 0; i < size; i++){
            rank[i] = 1;
        }
    }
    @Override
    public int getSize() {
        return this.count;
    }

    /*
    在寻找父节点的时候完成路径压缩 ---> 这次路径压缩的时候我们让当前节点的父节点直接指向最终的根节点即可
     */
    //定义一个辅助方法 --> 寻找根节点
    public int getParent(int index){
        int temp = index;
        while(index != parents[index]) {
            index = parents[index];
        }
        parents[temp] = index;
        return index;
    }

    //注意: 我们路径压缩的时候合并的时候是不需要变化的
    @Override
    public void union(int p, int q) {
        int pParent = getParent(p);
        int qParent = getParent(q);
        if(pParent != qParent) {
            //判断一下p结点的根节点的子树上的元素多还是q结点根节点为子树的结点多
            if(rank[pParent] > rank[qParent]) {
                //q结点的元素少, 所以让qparent指向pparent
                parents[qParent] = pParent;
            }else if(rank[pParent] < rank[qParent]){
                parents[pParent] = qParent;
            }else if(rank[pParent] == rank[qParent]) {
                parents[pParent] = qParent;
                rank[qParent]++;
            }
            count--;
        }
    }

    @Override
    public boolean isConnected(int p, int q) {
        return getParent(p) == getParent(q);
    }
}