Java并查集实现

并查集的用途

1. 网络中节点间的连接状态

•  网络是个抽象的概念：用户之间形成的网络
•   数学中集合类实现

2. 连接问题和路径问题

对一组数据，主要支持两个动作
    $union(p,q)$
    $isConnected(p,q)-->find(p)==find(q)$

并查集实现的接口

public interface UF {
    int getSize();
    boolean isConnected(int p, int q);
    void unionElements(int p, int q);
}

Quick Find

  快速查找时间复杂度

 unionElements(p,q)  --> O(n)
 isConnected(p,q)    --> O(1)

java代码实现

  这里仅仅是两个数组的id进行修改，连接在一起

public class UnionFind1 implements UF{
    private int[] id;

    public UnionFind1(int size) {
        id = new int[size];

        for (int i = 0; i < id.length; i++) {
            id[i] = i;
        }
    }

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

    //查找元素p所对应的集合编号
    private int find(int p) {
        if(p<0 && p>=id.length)
            throw new IllegalArgumentException("p is out of bound.");
        return id[p];
    }

    //查看元素p和元素q是否属一个集合
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    //合并元素p和元素q所属的集合
    @Override
    public void unionElements(int p, int q) {
        int pID = find(p);
        int qID = find(q);

        if (pID == qID)
            return;

        for (int i = 0; i < id.length; i++) {
            if(id[i] == pID)
                id[i] = qID;
        }
    }
}

Quick Union

  原理：将每一个元素，看做是一个节点，进行合并。

• 开始每个节点指向自己
  
  
• 两个元素进行合并
   让后面元素的根节点，指向前面根节点。
  

java代码实现

public class UnionFind2 implements UF {
    private int[] parent;

    public UnionFind2(int size) {
        parent = new int[size];

        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
        }
    }

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

    //查找过程，查找元素p所对应的集合编号
    //O(h)复杂度，h为树高度
    private int find(int p) {
        if(p<0 && p>=parent.length)
            throw new IllegalArgumentException("p is out of bound.");
        while (p!= parent[p])
            p = parent[p];
        return p;
    }

    //查看元素p和元素q是否属一个集合
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    //合并元素p和元素q所属的集合
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot)
            return;

        //根节点相连
        parent[pRoot] = qRoot;
    }
}

Quick Union – 基于size优化

基于每棵树的大小进行合并

• 对合并的元素不加判断，会不断增加树的高度，最后可能形成一个链表样子。

考虑size(当前树有多少节点)

• 让节点数少的那棵树的根节点指向节点数多的那棵树的根节点。

优化的代码

public class UnionFind3 implements UF {

    private int[] parent;
    private int[] sz;     //sz[i]表示以i为根的集合中元素个数

    public UnionFind3(int size) {
        parent = new int[size];
        sz = new int[size];

        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
            sz[i] = 1;
        }
    }

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

    //查找过程，查找元素p所对应的集合编号
    //O(h)复杂度，h为树高度
    private int find(int p) {
        if(p<0 && p>=parent.length)
            throw new IllegalArgumentException("p is out of bound.");
        while (p!= parent[p])
            p = parent[p];
        return p;
    }

    //查看元素p和元素q是否属一个集合
    //O(h)复杂度，h为树高
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    //合并元素p和元素q所属的集合
    //O(h)复杂度，h为树高
    @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]) {
            parent[pRoot] = qRoot;
            sz[qRoot] += sz[pRoot];
        }
        else {  // sz[qRoot] <= sz[pRoot]
            parent[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }
}

Quick Find – 基于rank优化

在合并时使用深度比较小的树指向深度比较大的树

• rank[i]表示根节点为i的树的高度

优化的代码

public class UnionFind4 implements UF {
    private int[] parent;
    private int[] rank;     //rank[i]表示以i为根的集合所表示的树的层数
    
    public UnionFind4(int size) {
        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < parent.length; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

	//与上面UnionFind3一致
	public int getSize(){}
	private int find(int p) {}
	public boolean isConnected(int p, int q) {}
	
	//合并元素p和元素q所属的集合
    //O(h)复杂度，h为树高
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot)
            return;

        // 根据两个元素所在树的rank判断合并方向
        // 将rank低的集合合并到rank高的集合
        if (rank[pRoot] < rank[qRoot])
            parent[pRoot] = qRoot;  //合并后，树的高度没有发生变化
        else if (rank[qRoot] < rank[pRoot])
            parent[qRoot] = pRoot;
        else {  // rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;  //合并后，高度应加一
        }
    }
}

路径压缩 Path Compression

让一棵比较高的树压缩成一个比较矮的树

• 通过parent[p] = parent[parent[p]]实现，如让4号节点断键后指向父亲的父亲节点2;

//查找过程，查找元素p所对应的集合编号
//O(h)复杂度，h为树高度
private int find(int p) {
    if(p<0 && p>=parent.length)
        throw new IllegalArgumentException("p is out of bound.");
    while (p!= parent[p]) {
        parent[p] = parent[parent[p]];  //路径压缩
        p = parent[p];
    }
    return p;
}

理想状态 --> 使用递归

• 全部指向一个根节点，即树高为2。

并查集的时间复杂度

   O(log*n)比O(logn)小

参考链接：liuyubobobo的github