并查集[Java实现]

1.并查集

并查集，是一种可以动态维护若干个不重叠的集合，支持合并和查询两种操作的一种数据结构。

2.基本操作

合并： 合并两个集合。
查询： 查询元素所属集合[即父集合]

3.实现

（1）初始化： 建立并查集数组parent[],parent[ i ]表示i的父节点，初始化每个节点的父节点为自己parent[ i ] = i。
（2）查询： 判断当前节点的父节点是否为自己，如果是，返回即可；若不是则继续递归寻找当前父节点的前辈节点，直至找到父节点为自身的节点，即为根节点，返回该节点。
（3）修改： 合并两个集合，只需要合并两个集合的根节点即可。即parent[ A ] = B，将两个节点关联即可。
（4）路径压缩： 将访问的每个子节点，直接指向根节点，便于后面寻找子节点的根节点。

以上思路及图源自Cyanigence，结合个人理解撰写了上面的文字。

4.代码实现

class DSU{
    int[] parent;

    public DSU(int len){
        parent = new int[len];
        for (int i = 0; i < len; i++) {
            parent[i] = i;
        }
    }
    public int find(int x){
        if(parent[x] != x){
            parent[x] = find(parent[x]);
        }
        return parent[x];
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
    }
    public void union(int x, int y){
        parent[find(x)] = find(y);
    }
}

可以结合LeetCode 1202.交换字符串中的元素 食用。

1202. 交换字符串中的元素
给你一个字符串 s，以及该字符串中的一些「索引对」数组 pairs，其中 pairs[i] = [a, b] 表示字符串中的两个索引（编号从 0 开始）。

你可以 任意多次交换 在 pairs 中任意一对索引处的字符。

返回在经过若干次交换后，s 可以变成的按字典序最小的字符串。

示例：

示例 1:
输入：s = "dcab", pairs = [[0,3],[1,2]]
输出："bacd"
解释： 
交换 s[0] 和 s[3], s = "bcad"
交换 s[1] 和 s[2], s = "bacd"

示例 2：
输入：s = "dcab", pairs = [[0,3],[1,2],[0,2]]
输出："abcd"

题中应用：

class Solution {
    public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
        char[] str = s.toCharArray();
        int len = s.length();
        DSU dsu = new DSU(len);
        // 构造下标集合
        for (List<Integer> temp : pairs) {
            dsu.union(temp.get(0), temp.get(1));
        }
        // 每个下标集合用leader作为key，下标集合List作为value
        HashMap<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < len; i++) {
            int key = dsu.find(i);
            List<Integer> temp = map.getOrDefault(key, new ArrayList<>());
            temp.add(i);
            map.put(key, temp);
        }
        for (List<Integer> list : map.values()) {
            if(list.size() > 1){
                sort(str, list);
            }
        }
        return new String(str);
    }
    // 根据list中下标，进行局部排序
    private void sort(char[] str, List<Integer> list){
        int len = list.size();
        char[] chs = new char[len];
        // 根据下标集合构建字符集合
        for (int i = 0; i < len; i++) {
            chs[i] = str[list.get(i)];
        }
        // 将字符集合排序
        Arrays.sort(chs);
        // 将字符按序插入回数组
        for (int i = 0; i < len; i++) {
            str[list.get(i)] = chs[i];
        }
    }
}

class DSU{
    int[] parent;

    public DSU(int len){
        parent = new int[len];
        for (int i = 0; i < len; i++) {
            parent[i] = i;
        }
    }
    public int find(int x){
        if(parent[x] != x){
            parent[x] = find(parent[x]);
        }
        return parent[x];
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
    }
    public void union(int x, int y){
        parent[find(x)] = find(y);
    }
}

本文参考了这篇文章，根据个人理解撰写本文。感谢作者。