算法与数据结构系列之[并查集-上]

1.概述

并查集是一种树形的数据结构，但是这种树很特殊，每棵树都是从子节点指向父节点的，在使用中也常常以森林来表示，用于解决一些不相交集合的合并和查询问题。

上面的概念有点抽象，其实并查集就是用来解决连接问题，并查集的查询其实就是判断两个元素是否属于同一个集合，两个元素属于同一个集合，那么他们就是连接的，否则不连接。并查集的并其实就是将不在同一个集合的两个元素合并，使其处于同一集合，在树中也就是表现的两个元素的节点连在一起或连在同一个父节点上。下面用图示说明此问题。

图一

上图一数字 1—9各自都为一个集合，都是一棵只有根节点的树，相互没有连接，这九棵树组成森林。

上图二4和6组合，4为根节点。 1,、2、5组合成一棵树，3、8、9、7组合成一棵树，但是1、2、5是按深度优先组合，3、8、9、7是按广度优先组合，广度优先组合比深度优先组合后树的深度要小，查找时效率较高。

图二

上图中如果将图一中的5和4组合，5和6组合，其结果都是图二，因为5和4组合就是将5所在树的根节点2指向4所在树的根节点，4本身就是根节点，即将2指向4即可。5和6组合也是将5所在的根节点2指向6所在树的根节点4，其实是完全一样的。

2.并查集的实现

1.数组实现：用数组存储集合的id,两个元素集合id相同说明在同一个集合，不同则不在同一个集合。初始时每一个元素对应一个集合id,每一个元素都属于一个不同的集合，将两个元素组合，就是遍历数组将这两个元素的集合id设置为同一个集合id，此时的时间复杂度为O(n)。查找时，只需要返回查找元素的集合id即可，所以查找的时间复杂度为O(1)，因此，这种并查树的实现也成为：Quick Find。

图三

java代码：

UF.java(接口定义)

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

实现代码

public class UnionFind1 implements UF {

    int[] id;  //存放集合id

    public UnionFind1(int size){
        id = new int[size];
        for (int i = 0; i < id.length; i++) {
            id[i] = i;  //初始化时每一个元素对应一个集合id，id数组中的每一个元素都不相同,每一个元素都没有和其他元素合并
        }
    }

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

    //查找索引为i的集合id
    private int find(int i){
        if(i < 0 || i>= id.length)
            throw new IllegalArgumentException("非法索引");
        return id[i];
    }

    //判断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;
        }
    }
}

2.使用树实现并查集：由子节点指向父节点的树，将父节点对应的元素存储在数组中，初始时父节点对应元素的数组中每个元素都不相同，表示每个节点都是父节点，都没有相连。两个元素组合时，将其对应的父节点的数组元素设置为相同即可，此时合并和查下的时间复杂度都为O(h),h为树的深度，相比较组合时要比数组实现的O(n)要快，因此这种并查集的实现也称作：Quick Union

图四

图五

java代码：

public class UnionFind2 implements UF{

    int[] parent;

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

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

    //查找i对应的集合编号
    //时间复杂度为O（h）,h为树的高度
    private int find(int i){
        if(i < 0 || i>= parent.length)
            throw new IllegalArgumentException("非法索引");
        while (i != parent[i])
            i = parent[i];
        return i;
    }

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

    //合并操作
    //时间复杂度为O（h）,h为树的高度
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if(pRoot == qRoot)
            return;
        parent[pRoot] = qRoot;
    }
}

接下来大致的测一下用数组实现和用树实现并查集的速度差异：

测试代码：

public class Test {
    private static double testUF(UF uf,int m){
        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a,b);
        }

        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a,b);
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int size = 10000;
        int m = 10000;
        UnionFind1 unionFind1 = new UnionFind1(size);
        System.out.println("UnionFind1: " + testUF(unionFind1,m) + " s");
        UnionFind2 unionFind2 = new UnionFind2(size);
        System.out.println("UnionFind2: " + testUF(unionFind2,m) + " s");
        /*UnionFind3 unionFind3 = new UnionFind3(size);
        System.out.println("UnionFind3: " + testUF(unionFind3,m) + " s");
        UnionFind4 unionFind4 = new UnionFind4(size);
        System.out.println("UnionFind4: " + testUF(unionFind4,m) + " s");
        UnionFind5 unionFind5 = new UnionFind5(size);
        System.out.println("UnionFind5: " + testUF(unionFind5,m) + " s");
        UnionFind6 unionFind6 = new UnionFind6(size);
        System.out.println("UnionFind6: " + testUF(unionFind6,m) + " s");*/
    }
}

上面的测试代码执行了两个方法：uf.unionElements(a,b)和 uf.isConnected(a,b)。对于数组实现的uf.isConnected(a,b)方法时间复杂度为O(1), uf.isConnected(a,b)方法复杂度为O(n),执行次数是size次，树实现的两个方法的时间复杂度都为O(h),执行两个方法的整体速度要好于数组实现。

执行结果：

图六

将size和调用次数m都赋值为100000时，树实现的整体速度就会下降，因为size越大，树的深度越大，两个O(h)的复杂度使得整体效率变差。

图七

3.总结

这篇介绍了并查集的概述和两种实现方法，虽然当操作数变大时，树实现的并查集会相应变慢，但常用的还是第二种方法，用树来实现并查集，其实用树来实现并查集还有一些优化方法，能够使其速度远大于用数组实现的速度。
下一篇将会介绍几种优化并查集的方法。

本人微信公众号，点关注，不迷路