简单并查集归纳

并查集就是一种一边查找一边并集的数据结构，简单的并查集经常应用于朋友圈等题目，即：x和y是朋友，y和z是朋友，则x和z是朋友，下面给出一组数据表示xx和yy是朋友，最后问一共有多少个朋友圈。这类问题一般用并查集解决比较快。
下面明确并查集做的事情：
1.查集，即查找某个元素是否包含在一个集合里面
2.并集，即将两个集合合并到一块
知道并查集要做的事后，实现它就比较简单了，数据结构书上教我们的是用树的方法来实现并查集，即用一个数组来模拟树，然后利用树的特性来实现，但是那个一下子会有点难以理解，所以我们一开始可以用java自带的集合类来模拟实现，帮助理解。
下面是用java集合来实现并查集的代码：

import java.io.*;
import java.util.*;

public class javaSet_union_find_set {
    static int n;
    static List<Set<Integer>>list = new ArrayList<Set<Integer>>();
    public static void main(String[] args){
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        n = in.nextInt();
        //初始化，为每个人单独建立一个集合
        for(int i=1;i<=n;i++){
            Set<Integer>set = new HashSet<Integer>();
            set.add(i);
            list.add(set);
        }
        int m = in.nextInt();
        for(int i=0;i<m;i++){
            int x = in.nextInt();
            int y = in.nextInt();
            union(x,y);
        }
        for(int i=0;i<list.size();i++){
            System.out.println("集合"+i+":");
            System.out.print("( ");
            for(int number:list.get(i)){
                System.out.print(number+" ");
            }
            System.out.print(")
");
        }
        System.out.println(list.size());
    }
    //查集操作，返回一个集合，即元素所在的集合
    public static Set<Integer> find(int x){
        for(Set set:list){
            if(set.contains(x)){
                return set;
            }
        }
        return null;
    }
    //并集操作，将两个元素所在的集合合并
    public static void union(int a,int b){
        Set<Integer>set1 = find(a);
        Set<Integer>set2 = find(b);
        //当两个集合不相等的时候，合并他们
        if(set1!=set2){
            list.remove(set1);
            list.remove(set2);
            set1.addAll(set2);
            list.add(set1);
        }
    }
}

所用到的思想就是简单并查集的思想，下面我们假设一组数据来具体说明，
测试数据：
6 4
1 2
1 3
1 4
5 6
第一行第一个数为n，即一共有多少个人，第二个数为m，即以下给出m对关系，接着m行，每行两个数，表示第x个人和第y个人是朋友关系
答案：
2
最后应该是，1,2,3,4是一组朋友关系，5,6是一组朋友关系，故一共有两个朋友圈
用并查集来解决这个问题，就是要运用集合的特性，即两个集合有并集操作。
故，我们一开始给每一个人创建一个集合，即每个人都是单独的一个集合，下面给出初始关系，用（）表示一个集合。
初始关系为：(1),(2),(3),(4),(5),(6)
对m行数据进行处理：
1和2是朋友，那么包含1的集合和包含2的集合合并，则现在关系为：
(1,2),(3),(4),(5),(6)
1和3是朋友，并集后：
(1,2,3),(4),(5),(6)
1和4是朋友,并集后：
(1,2,3,4),(5),(6)
5和6是朋友，并集后:
(1,2,3,4),(5,6)
这就是完整的一次集合操作，最后数组list的长度即为朋友圈的个数

上面用java的集合类Set模拟了一下并查集的具体操作，每次查集的时间复杂度为数组的长度即O(N)，每次并集的复杂度为原本java集合类并集的复杂度，有m次查询，粗略计算时间复杂度为O(mn),即O(N),也算是线性复杂度吧。
接下来是传统做法，用数组模拟树来实现，用数组模拟树实现并查集如下所示：

一开始每个人都是独立的集合
(1),(2),(3),(4),(5),(6)
1和2是朋友，并集后:
(1),(3),(4),(5),(6)
 |
(2)
1和3是朋友，并集后：
(1)  ,(4),(5),(6)
 | 
(2) (3)
1和4是朋友，并集后：
  (1) ,(5),(6)
 / | 
(4)(2)(3)
5和6是朋友，并集后：
  (1) ,    (5)
 / |       |
(4)(2)(3)  (6)

上面只是模拟了并查集操作，具体的指向为具体的程序的启发函数决定。
使用数组模拟树的并查集有以下几点需要注意：
1.路径压缩操作，在并集操作中很可能出现下面这个情况：

    (1)       (5)
     |         |
    (2)       (6)
     |
    (3)
     |
    (4)

当出现这种树的时候，进行查集操作的时候会额外消耗更多的查询时间。
所以这时要运用路径压缩的方法，即每次进行查询操作的时候都进行路径压缩，即查询子节点的时候，都将子节点指向根节点
2.并集操作中怎么合并两个集合，应该根据什么来进行合并
这里有两个启发函数可以选择：
1.根据节点数量进行合并，即将节点少的树结合到节点数量多的树中
2.根据树的高度进行合并，即将高度小的树合并到高度高的树
下面两个启发函数分别举例，先是使用启发函数1+路径压缩的做法，代码如下：

import java.io.*;
import java.util.*;

public class union_find_set {
    //父节点数组，father[x]=y表示x的父节点为y
    //如果father[x]小于0，则说明x是一个根节点，此时father[x]的绝对值是
    //这颗树的节点数量
    static int[] father;
    static int n;
    public static void main(String[] args){
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        n = in.nextInt();
        int m = in.nextInt();
        father = new int[n+1];
        //初始化父节点数组
        for(int i=0;i<=n;i++){
            father[i] = -1;
        }
        for(int i=0;i<m;i++){
            int x = in.nextInt();
            int y = in.nextInt();
            union(x,y);
        }
        for(int i=1;i<=n;i++){
            System.out.println("find("+i+"):"+find(i));
        }
    }
    //查集操作，查找x元素所属的集合的根节点，同时进行路径压缩操作
    public static int find(int x){
        int root = x;
        while(root>=0){
            root = father[root];
        }
        //此时已找到根节点为root
        
        //路径压缩
        while(x!=root){
            int temp = x;
            x = father[x];    //x继续往上一个父节点追溯，直到根节点
            father[temp] = root;    //路径压缩，把所有子节点都直接指向根节点
        }
        
        return root;
    }
    //并集操作，将两个集合合并,将x元素所属的集合和y元素所属的集合合并
    public static void union(int x,int y){
        int fx = find(x);
        int fy = find(y);
        //temp的绝对值为两棵树的节点数量总和
        int temp = fx + fy;
        //说明x元素所属的集合节点比y元素所属的集合少
        //那么将节点少的集合合并到节点多的集合上
        if(fx>fy){
            father[x] = y;
            father[y] = temp;
        }else{
            father[x] = temp;
            father[y] = x;
        }
    }
}

使用启发函数1的做法，那么模拟树的数组有一点要注意的就是，为负数的时候表示这是一个根节点，并且此负数的相反数为该棵树的节点总数
一下是使用启发函数2的做法，代码如下：

import java.io.*;
import java.util.*;

//使用启发函数2的做法
public class union_find_set_another {
    static int[] father;    //记录每个节点的父节点，father[x]=y表示为x元素的父节点为y元素
    static int[] rank;        //记录每棵树的高度，rank[x]=h表示为x元素所含集合的深度为h
    static int n;
    public static void main(String[] args){
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        n = in.nextInt();
        father = new int[n+1];
        rank = new int[n+1];
        int m = in.nextInt();
        //初始化father数组
        //令每个节点一开始都指向自己
        for(int i=0;i<=n;i++){
            father[i] = i;
        }
        //初始化rank数组
        for(int i=0;i<=n;i++){
            rank[i] = 1;
        }
        for(int i=0;i<m;i++){
            int x = in.nextInt();
            int y = in.nextInt();
            union(x,y);
        }
        for(int i=1;i<=n;i++){
            System.out.println("find("+i+"):"+find(i));
        }
    }
    public static int find(int x){
        if(x!=father[x]){
            return find(father[x]);
        }
        return x;
    }
    public static void union(int x,int y){
        int fx = find(x);
        int fy = find(y);
        if(fx==fy){
            //说明两个元素同属一个集合，这种情况直接返回
            return;
        }
        //此处应用启发函数2，根据树的高度来进行合并
        //这里我们将高度小的合并到高度大的树上
        if(rank[fx]>rank[fy]){
            father[fy] = fx;
        }else{
            if(rank[fx]==rank[fy]){
                //当两棵树一样高的时候，则增加其中一棵的高度
                rank[fy]++;
            }
            father[fx] = fy;
        }
    }
}

启发函数2中额外使用了一个rank数组来记录树的高度，并让father数组严格遵守father[x]=y表示x的父节点为y这一个规定，使用find函数查找根节点会返回根节点的值，而不是节点数量，这一点比启发函数1来的好用，再加上代码短，思路清晰这一点，我是建议都用启发函数2来实现的>.<
简单并查集的归纳就到这里了，如果想验证代码的正确性的话，下面有几个题目可以选择：
https://leetcode.com/problems/friend-circles/description/   leetcode的朋友圈问题，经典的并查集应用
http://codevs.cn/problem/2597/   团伙问题，敌人的敌人是朋友是需要注意的一点

最后说几句，这篇文章是我从《算法竞赛宝典》数据结构一章归纳总结而来，如果有什么问题或纰漏，请您指出，本人感激不尽~~~