数据结构-并查集

简介

并查集(Disjoint-Set)是一种可以动态维护若干个不重叠的集合，并支持合并与查询两种操作的一种数据结构。
就是维护多个集合之间的关系，集合的合并和查询定位（哪个元素属于哪些集合等查询操作），所以并查集主要包括两种操作：

• 合并（Union）：合并两个集合；
• 查询（Find）：查询元素属于哪些集合。

由上面的概念，我们可以知道并查集主要解决以下几个个问题：

• 合并两个或多个集合；
• 判断某一个元素或者多个元素是否属于某个集合

分析

慢union,快find

我们可以用数组来表示数据结构（并查集表示的是多个集合之间的关系，使用map不能直观的描述多个集合的关系），数组的下标代表元素，存储的内容代表所在的集合，如下：

此时假如我们需要将元素2合并到元素1所在集合,则直接使arr[2]=arr[1]就行了

假如我们要将1集合加入到3集合，也就是元素1和元素2加入到3的集合中，则需要将元素1和元素2所在的集合做更改，arr[1]=3,arr[2]=3,合并的时间复杂度为O(n)

这时判断元素1和元素2是否在同一个集合只需要判断数组内值是否相等即可arr[1]==arr[2],相等则说明属于同一个集合，时间复杂度为O(1)
示例代码如下(慢union,快)：

package com.example.demo;

public class Test {

    private static int[] arr = new int[]{0,1,2,3,4,5,6,7};

    public static void main(String[] args) throws Exception {
        System.out.println("元素所在集合初始：" );
        arrToString(arr);
        System.out.println("将元素2合并到元素1所在集合");
        union(2,1);
        arrToString(arr);
        System.out.println("将元素1、2合并到3所在集合");
        union(1,3);
        arrToString(arr);
    }

    /**
     * 查看元素属于哪个集合
     * 时间复杂度为 O（1）
     * @param index
     * @return
     */
    public static int find(int index){
        return arr[index];
    }

    /**
     * 判断两个元素是否属于同一个集合
     * @param first
     * @param second
     * @return
     */
    public static boolean isTogether(int first, int second){
        return find(first) == find(second);
    }

    /**
     * 时间复杂度为 O（n）
     * 将first元素所在集合合并到second元素所在集合
     * @param first
     * @param second
     */
    public static void union(int first, int second){
        int m1 = find(first);
        int m2 = find(second);

        for(int i = 0; i < arr.length;i++){
            if(arr[i] == m1 ){
                arr[i] = m2;
            }
        }

    }

    public static void arrToString(int[] arr){
        if(null == arr || arr.length <= 0){
            return;
        }
        System.out.print("数组元素：");
        for(int i = 0 ; i < arr.length ; i ++){
            System.out.print(i + " " );
        }
        System.out.println("");
        System.out.print("所在集合：");
        for(int c : arr){
            System.out.print(c + " ");
        }
        System.out.println("");
    }

}

输出：
元素所在集合初始：
数组元素：0 1 2 3 4 5 6 7
所在集合：0 1 2 3 4 5 6 7
将元素2合并到元素1所在集合
数组元素：0 1 2 3 4 5 6 7
所在集合：0 1 1 3 4 5 6 7
将元素1、2合并到3所在集合
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 3 3 4 5 6 7

上面的方法union时间复杂度是O（n）,每次合并都需要把需要合并的集合遍历一遍，当集合内数据很大时肯定是不行的，我们需要对union进行优化

快union,慢find

我们将上面的关系转化为树形结构,改成树形结构时我们需要对数组进行小调整，数组下标依然表示元素，数组内容需要变为父集合。
上面我们将2加入1，则元素2的父集合就是1所在的集合，1加入3则元素1的父集合就是3所在的集合，稍做调整后的数组结为arr[2]=arr[1],arr[1]=arr[3],如图：

树形结构如下图：

这个时候假如我们将3集合合并到4集合，其实只需要把领头的元素3加入到4集合，元素1，2，3的关系保持不变就可以了，只需要操作一步就完成了合并操作。这个时候数据结构就从数组转变成了树形结构，成功的将union时间复杂度变为了O（1）

再来看find(1),需要找到顶部元素所在集合（也就是元素4所在集合）即可，时间复杂度取决于树的深度
示例代码：

package com.example.demo;

public class Test2 {

    private static int[] arr = new int[]{0,3,1,3,4,5,6,7};

    public static void main(String[] args) throws Exception {
        System.out.println("元素所在集合初始：");
        arrToString(arr);
        System.out.println("将元素3所在集合合并到元素4所在集合");
        union(3, 4);
        arrToString(arr);
    }

    /**
     * 查看元素属于哪个集合
     * 时间复杂度为 O（1）
     * @param index
     * @return
     */
    public static int find(int index){
        // 判断自己是不是顶部节点 没有父集合就是顶部元素
        while(index != arr[index]){
            //如果不是顶部元素  则往上查找  知道找到顶部元素为止
            //顶部元素所在的集合就是该元素所在的集合
            index = arr[index];
        }
        return index;
    }

    /**
     * 判断两个元素是否属于同一个集合
     * @param first
     * @param second
     * @return
     */
    public static boolean isTogether(int first, int second){
        return find(first) == find(second);
    }

    /**
     * 时间复杂度为 O（n）
     * 将first元素所在集合合并到second元素所在集合
     * @param first
     * @param second
     */
    public static void union(int first, int second){
        int firstRoot = find(first);
        int secondRoot = find(second);
        // 如果所属集合相等则不操作
        if(firstRoot == secondRoot){
            return ;
        }
        // 否则将first元素所在集合的顶部元素所在的父集合指向元素second顶部元素所在的集合，则完成了合并
        arr[firstRoot] = secondRoot;
    }

    public static void arrToString(int[] arr){
        if(null == arr || arr.length <= 0){
            return;
        }
        System.out.print("数组元素：");
        for(int i = 0 ; i < arr.length ; i ++){
            System.out.print(i + " " );
        }
        System.out.println("");
        System.out.print("所在集合：");
        for(int c : arr){
            System.out.print(c + " ");
        }
        System.out.println("");
    }

}

输出：
元素所在集合初始：
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 1 3 4 5 6 7
将元素3所在集合合并到元素4所在集合
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 1 4 4 5 6 7

快速union，快速find，基于重量

上面的例子中我们要找到2所在的集合需要把整个集合都遍历一遍，这是因为每次合并时都是往父一级追加，形成了线性链表，上面的优化导致了find方法时间复杂度为集合深度。为了再次优化find方法，我们需要优化树结构的生成规则。既然两个元素合并到一个元素，以上面的例子举例，元素3合并到元素4和元素4合并到元素3其实是一个效果，但是显然元素4合并到元素3更为合理。也就是谁元素多谁为主，元素少的集合合并到元素多的集合中，这样就能降低树的深度提高find效率了

示例代码：

package com.example.demo;

public class Test3 {

    private static int[] arr    = new int[]{0,3,1,3,4,5,6,7};
    private static int[] weight = new int[]{1,1,0,2,1,1,1,1};

    public static void main(String[] args) throws Exception {
        System.out.println("元素所在集合初始：");
        arrToString(arr);
        System.out.println("将元素3所在集合和元素4所在集合合并");
        union(3, 4);
        arrToString(arr);
    }

    /**
     * 查看元素属于哪个集合
     * 时间复杂度为 O（1）
     * @param index
     * @return
     */
    public static int find(int index){
        // 判断自己是不是顶部节点 没有父集合就是顶部元素
        while(index != arr[index]){
            //如果不是顶部元素  则往上查找  知道找到顶部元素为止
            //顶部元素所在的集合就是该元素所在的集合
            index = arr[index];
        }
        return index;
    }

    /**
     * 判断两个元素是否属于同一个集合
     * @param first
     * @param second
     * @return
     */
    public static boolean isTogether(int first, int second){
        return find(first) == find(second);
    }

    /**
     * 时间复杂度为 O（n）
     * 将first元素所在集合合并到second元素所在集合
     * @param first
     * @param second
     */
    public static void union(int first, int second){
        int firstRoot = find(first);
        int secondRoot = find(second);
        // 如果所属集合相等则不操作
        if(firstRoot == secondRoot){
            return ;
        }
        // 取出所在集合元素个数
        int fweight = weight[firstRoot];
        int sweight = weight[secondRoot];
        if(fweight < sweight){
            //若second所在集合元素个数大于first所在集合元素个数
            // 则将first元素加入second元素所在集合
            arr[firstRoot] = secondRoot;
            weight[secondRoot] = sweight + fweight ;
        }else{
            // 于上面相反
            arr[secondRoot] = firstRoot;
            weight[firstRoot] = fweight + sweight;

        }

    }

    public static void arrToString(int[] arr){
        if(null == arr || arr.length <= 0){
            return;
        }
        System.out.print("数组元素：");
        for(int i = 0 ; i < arr.length ; i ++){
            System.out.print(i + " " );
        }
        System.out.println("");
        System.out.print("所在集合：");
        for(int c : arr){
            System.out.print(c + " ");
        }
        System.out.println("");
        System.out.print("集合重量：");
        for(int c : weight){
            System.out.print(c + " ");
        }
        System.out.println("");
    }

}

元素所在集合初始：
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 1 3 4 5 6 7
集合高度：1 1 0 2 1 1 1 1
将元素3所在集合合并到元素4所在集合
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 1 3 3 5 6 7
集合重量：1 1 0 3 1 1 1 1

观察上面输出可以看到元素4加入了集合3

快速union，快速find，基于高度(基于秩)

对于上述改进方法，只是单纯的判断集合内元素的个数大小来决定如何合并集合，如果数据结构是如下图时：

假如按照元素个数谁大合并到谁那则会出现下面的情况

集合5加入了集合3，树的高度变为了4，极端情况下find的时间复杂度会无限接近o(n)(无限接近线性链表的结构)。假如我们按照树的高度来判断合并到哪个集合，上述情况合并会得到：

示例代码：

package com.example.demo;

public class Test4 {

    private static int[] arr    = new int[]{0,3,3,3,3,5,5,6};
    private static int[] height = new int[]{1,1,1,2,1,3,2,1};

    public static void main(String[] args) throws Exception {
        System.out.println("元素所在集合初始：");
        arrToString(arr);
        System.out.println("将元素3所在集合和元素5所在集合合并");
        union(3, 5);
        arrToString(arr);
    }

    /**
     * 查看元素属于哪个集合
     * 时间复杂度为 O（1）
     * @param index
     * @return
     */
    public static int find(int index){
        // 判断自己是不是顶部节点 没有父集合就是顶部元素
        while(index != arr[index]){
            //如果不是顶部元素  则往上查找  知道找到顶部元素为止
            //顶部元素所在的集合就是该元素所在的集合
            index = arr[index];
        }
        return index;
    }

    /**
     * 判断两个元素是否属于同一个集合
     * @param first
     * @param second
     * @return
     */
    public static boolean isTogether(int first, int second){
        return find(first) == find(second);
    }

    /**
     * 时间复杂度为 O（n）
     * 将first元素所在集合合并到second元素所在集合
     * @param first
     * @param second
     */
    public static void union(int first, int second){
        int firstRoot = find(first);
        int secondRoot = find(second);
        // 如果所属集合相等则不操作
        if(firstRoot == secondRoot){
            return ;
        }
        // 取出所在集合元素个数
        int fheight = height[firstRoot];
        int sheight = height[secondRoot];
        if(fheight < sheight){
            //若second所在集合高度大于first所在集合高度
            // 则将first元素加入second元素所在集合
            // 高度取决于最高的集合 所以最大高度并不会改变
            arr[firstRoot] = secondRoot;
        }else if(fheight == sheight){
            //若second所在集合高度和first所在集合高度  相等
            // 则将first元素加入second元素所在集合
            // 高度+1
            arr[firstRoot] = secondRoot;
            height[secondRoot] = sheight + 1;
        }else{
            //若second所在集合高度小于first所在集合高度
            // 则将second元素加入first元素所在集合
            // 高度不变
            arr[secondRoot] = firstRoot;
        }

    }

    public static void arrToString(int[] arr){
        if(null == arr || arr.length <= 0){
            return;
        }
        System.out.print("数组元素：");
        for(int i = 0 ; i < arr.length ; i ++){
            System.out.print(i + " " );
        }
        System.out.println("");
        System.out.print("所在集合：");
        for(int c : arr){
            System.out.print(c + " ");
        }
        System.out.println("");
        System.out.print("集合高度：");
        for(int c : height){
            System.out.print(c + " ");
        }
        System.out.println("");
    }

}

输出：
元素所在集合初始：
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 3 3 3 5 5 6
集合高度：1 1 1 2 1 3 2 1
将元素3所在集合和元素5所在集合合并
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 3 5 3 5 5 6
集合高度：1 1 1 2 1 3 2 1

最大高度还是3没有变化

路径压缩

针对基于重量的优化，我们可以将叶子节点直接指向父元素的父元素所在集合，这样也能压缩树的高度，提高find性能。这种方法实际上没有改变树的结构，只是直接越级查找了
示例代码：

package com.example.demo;

public class Test32 {

    private static int[] arr    = new int[]{0,3,1,3,4,5,6,7};
    private static int[] weight = new int[]{1,1,0,2,1,1,1,1};

    public static void main(String[] args) throws Exception {
        System.out.println("元素所在集合初始：");
        arrToString(arr);
        System.out.println("将元素3所在集合和元素4所在集合合并");
        union(3, 4);
        arrToString(arr);
    }

    /**
     * 查看元素属于哪个集合
     * 时间复杂度为 O（1）
     * @param index
     * @return
     */
    public static int find(int index){
        // 判断自己是不是顶部节点 没有父集合就是顶部元素
        while(index != arr[index]){
            //如果不是顶部元素  则往上查找  知道找到顶部元素为止
            // 这里查找采用路径压缩法，越过一级往上查找
            index = arr[arr[index]];
        }
        return index;
    }

    /**
     * 判断两个元素是否属于同一个集合
     * @param first
     * @param second
     * @return
     */
    public static boolean isTogether(int first, int second){
        return find(first) == find(second);
    }

    /**
     * 时间复杂度为 O（n）
     * 将first元素所在集合合并到second元素所在集合
     * @param first
     * @param second
     */
    public static void union(int first, int second){
        int firstRoot = find(first);
        int secondRoot = find(second);
        // 如果所属集合相等则不操作
        if(firstRoot == secondRoot){
            return ;
        }
        // 取出所在集合元素个数
        int fweight = weight[firstRoot];
        int sweight = weight[secondRoot];
        if(fweight < sweight){
            //若second所在集合元素个数大于first所在集合元素个数
            // 则将first元素加入second元素所在集合
            arr[firstRoot] = secondRoot;
            weight[secondRoot] = sweight + fweight;
        }else{
            // 于上面相反
            arr[secondRoot] = firstRoot;
            weight[firstRoot] = fweight + sweight;

        }

    }

    public static void arrToString(int[] arr){
        if(null == arr || arr.length <= 0){
            return;
        }
        System.out.print("数组元素：");
        for(int i = 0 ; i < arr.length ; i ++){
            System.out.print(i + " " );
        }
        System.out.println("");
        System.out.print("所在集合：");
        for(int c : arr){
            System.out.print(c + " ");
        }
        System.out.println("");
        System.out.print("集合重量：");
        for(int c : weight){
            System.out.print(c + " ");
        }
        System.out.println("");
    }

}

输出：
元素所在集合初始：
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 1 3 4 5 6 7
集合重量：1 1 0 2 1 1 1 1
将元素3所在集合和元素4所在集合合并
数组元素：0 1 2 3 4 5 6 7
所在集合：0 3 1 3 3 5 6 7
集合重量：1 1 0 3 1 1 1 1

应用场景：

并查集在很多场景都可以使用，比如地图寻址，im的群查找合并，数据统计等
例如：https://blog.csdn.net/jert159/java/article/details/38617095