(十二) 并查集-java实现

并查集

什么是并查集

在计算机科学中，并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（union-find algorithm）定义了两个用于此数据结构的操作：

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

并查集的表示方法

初始化一个数组. 此数组表示一个集合, 比如上图MakeSet创建的8个元素. 此时这八个元素分别在不同的集合中, 自身表示一个集合.

数组中存储每个元素的父节点形成一棵树. 当两棵树的根节点相同的时候, 证明两个元素在同一个集合中. Find操作,就是查看两棵树在不在同一棵树中. Union操作就是将不同的两个集合合并成一个集合.

代码

最简陋的并查集(没有进行优化)

package pers.jssd;

/**
 * Quick Union的实现, 只是一棵树
 *
 * @author jssdjing@gmail.com
 */
public class UnionFind2 implements UF {

    private int[] data;

    public UnionFind2(int size) {
        data = new int[size];
        for (int i = 0; i < data.length; i++) {
            data[i] = i;
        }
    }

    @Override
    public int getSize() {
        return data.length;
    }

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

    private int find(int p) {
        if (p < 0 || p >= data.length) {
            throw new IllegalArgumentException("find error, index is out of bound");
        }
        while (p != parent(p)) {
            p = parent(p);
        }
        return p;
    }

    private int parent(int p) {
        return data[p];
    }

    /**
     * 将qRoot的父元素设置为pRoot, 修改之前qRoot的父元素应该为他自己
     *
     * @param p 第一个元素的下标
     * @param q 第二个元素的下标
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot != qRoot) {
            data[qRoot] = pRoot;
        }
    }
}

基于rank的优化

在没有优化的时候, 每次合并都有可能将树的深度提高. 我们使用find方法的时候, 是遍历树的深度. 所以树的深度越高, 算法的效率就越低下. 所以在Union的时候, 将rank小的, 合并到rank大的上.

package pers.jssd;

/**
 * 基于size的优化, 让节点个数小的树的根节点, 指向节点个数多的树的根节点
 *
 * @author jssdjing@gmail.com
 */
public class UnionFind3 implements UF {

    private int[] data;
    // 维护着树的大小 (其中的节点个数)
    private int[] sz;

    public UnionFind3(int size) {
        data = new int[size];
        sz = new int[size];
        for (int i = 0; i < data.length; i++) {
            data[i] = i;
            sz[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return data.length;
    }

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

    private int find(int p) {
        if (p < 0 || p >= data.length) {
            throw new IllegalArgumentException("find error, index is out of bound");
        }
        while (p != parent(p)) {
            p = parent(p);
        }
        return p;
    }

    private int parent(int p) {
        return data[p];
    }

    /**
     * 基于size的优化, 哪里的树的深度低, 就让哪里的元素连接到另一个元素上. 此时会降低树的高度, 大幅度提升效率
     *
     * @param p 第一个元素的下标
     * @param q 第二个元素的下标
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot == qRoot) {
            return;
        }
        if (sz[pRoot] > sz[qRoot]) {
            data[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        } else {
            data[pRoot] = qRoot;
            sz[qRoot] += sz[pRoot];
        }
    }
}

路径压缩

在使用rank优化之后, 树的深度有了一定的降低. 但是不是最优的情况. 最优情况是树的深度为二, 所有同一集合的节点指向统一个节点. 每次find的时候, 会遍历树的深度, 所以可以在find操作的时候, 将此节点指向此节点的父节点的父节点, 就会降低树的深度

package pers.jssd;

/**
 * 对数的深度进行了优化, 使用路径压缩算法. 在find的时候, 顺便将树的深度进行改变. 让此节点的父节点等于此节点的父节点的父节点.
 * 这个时候, 树的深度会变小. rank是不需要维护的, 维护rank的成本比较高, 所以使用模糊的rank作为高度排名即可
 *
 * @author jssdjing@gmail.com
 */
public class UnionFInd5 implements UF {

    private int[] data;
    private int[] rank;

    public UnionFInd5(int size) {
        data = new int[size];
        rank = new int[size];
        for (int i = 0; i < data.length; i++) {
            data[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return data.length;
    }

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

    private int find(int p) {
        if (p < 0 || p >= data.length) {
            throw new IllegalArgumentException("find error, index is out of bound");
        }
        while (p != parent(p)) {
            // 让此树的父节点指向父节点的父节点
            data[p] = data[data[p]];
            p = parent(p);
        }
        return p;
    }

    private int parent(int p) {
        return data[p];
    }

    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot == qRoot) {
            return;
        }
        if (rank[pRoot] > rank[qRoot]) {
            data[qRoot] = pRoot;
        } else if (rank[qRoot] > rank[pRoot]) {
            data[pRoot] = qRoot;
        } else {
            data[qRoot] = pRoot;
            rank[pRoot] ++;
        }
    }
}