一、啥是并查集
1、解释
看下维基百科的解释
啥？在说啥，看不懂？那说人话吧
通俗的说，并查集是一种数据结构，指在一些有N个元素的集合应用问题中，通常在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。用于处理一些不相交集合的合并及查询问题。
2、有啥优势
在足够多的合并和查询操作后，均摊下来单次的查询时间复杂度是O(1)。
3、作用
解决类似图的连通性问题大量使用并查集。
二、主要操作
1、初始化：把每个点所在集合初始化为其自身
通常来说，这个步骤在每次使用该数据结构时只需要执行一次，无论何种实现方式，时间复杂度均为O(N)。
2、查找：查找元素所在的集合，即此集合的代表节点——根节点
3、合并：将两个元素所在的集合合并为一个集合。集合小的连到集合大的
通常来说，合并之前，应先判断两个元素是否属于同一集合，这可用上面的“查找”操作实现。
三、路径优化压缩
1、思想：每次查找的时候，如果路径较长，则修改信息，以便下次查找的时候速度更快。
2、实现：第一步，找到根结点；第二步，修改查找路径上的所有节点，将它们都指向根结点。
为啥最后均摊的时间复杂度是O(1)？
路径优化压缩是关键
因为每次在查找时，都会把此路径上所有的节点重新全部直接连到根节点上，以后再查找时都是一步到位，一步就找到了根节点，除了查找根节点以外的操作本身就是O(1)，而一个路径上重新调整的操作只会执行一次，所以最后均摊下来的时间复杂度是O(1)。
关于时间复杂度O(1)的证明
并查集最早由Bernard A. Galler和Michael J. Fischer于1964年提出，但是直到Fredman 和 Saks 在 1989 年才证明了任何并查集都需要O(1)的均摊时间来完成每次操作，25年才证明完成。
四、核心方法
/**
* @author Java和算法学习：周一
*/
public static class UnionFind {
// 用户输入的V对应内部的Node
public HashMap> nodes;
// Node的父亲是谁
public HashMap, Node> parents;
// Node所在集合的大小（只有集合的代表节点<可以理解为头节点>才会放到sizeMap中）
public HashMap, Integer> sizeMap;
// 初始化时把用户给定的数据全部放到各个Map中
public UnionFind(List values) {
nodes = new HashMap<>();
parents = new HashMap<>();
sizeMap = new HashMap<>();
for (V current : values) {
Node node = new Node<>(current);
nodes.put(current, node);
// 初始化时node的父亲是自己
parents.put(node, node);
// 初始化时node的size是1
sizeMap.put(node, 1);
}
}
}
1、查找节点所在集合的代表节点
/**
* 找到指定节点所在的代表节点
*
* @author Java和算法学习：周一
*/
public Node findHead(Node node) {
Node current = node;
Stack> stack = new Stack<>();
// 当前节点的父节点不是自己，说明还没找到最顶
while (current != parents.get(current)) {
stack.push(current);
current = parents.get(current);
}
// 优化：修改查找路径上的所有节点，将它们都指向根结点
while (!stack.isEmpty()) {
parents.put(stack.pop(), current);
}
return current;
}
2、isSameSet(V a, V b)
判断a、b所代表的两个集合是否在同一个集合中
/**
* 判断两个节点所在集合是不是同一个集合
*
* @author Java和算法学习：周一
*/
public boolean isSameSet(V a, V b) {
return findHead(nodes.get(a)) == findHead(nodes.get(b));
}
3、union(V a, V b)
将a、b所代表的两个集合合并为一个集合
/**
* 将两个节点所在集合合并为一个集合
*
* @author Java和算法学习：周一
*/
public void union(V a, V b) {
Node aHead = findHead(nodes.get(a));
Node bHead = findHead(nodes.get(b));
if (aHead != bHead) { // 说明a、b所在集合不是同一个集合
int aSize = sizeMap.get(aHead);
int bSize = sizeMap.get(bHead);
// 找到size更大的集合
Node big = aSize >= bSize ? aHead : bHead;
Node small = big == aHead ? bHead : aHead;
// 小的连到大的上面（这也是一个优化）
parents.put(small, big);
// 重新调整big所在集合的size
sizeMap.put(big, aSize + bSize);
// small所在集合已经连到big上，从sizeMap中移除
sizeMap.remove(small);
}
}
五、省份数量问题
1、题目描述
LeetCode547
https://leetcode-cn.com/probl...
有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。
省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。
给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。
返回矩阵中 省份 的数量。
2、示例
输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
[1, 1, 0]
[1, 1, 0]
[0, 0, 1]
输出：2
3、思路
如果知道使用并查集来求解，这题就水到渠成了，挨个将相连的城市使用并查集合并到一起，最后求并查集中集合的数量就是省份的数量了。相当于并查集就可以当一个黑盒来使用了。
4、代码
为了优化代码的执行时间，将最初由Map表示的集合采用一维数组来表示。
/**
* @author Java和算法学习：周一
*/
public int findCircleNum(int[][] isConnected) {
int length = isConnected.length;
UnionFind unionFind = new UnionFind(length);
// 因为整个 n*n 的二维矩阵是关于对角线对称的，而自己和自己是相连的，即对角线都是1，所以只需遍历一侧即可
// 我们遍历的是右上方的数据
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (isConnected[i][j] == 1) {
unionFind.union(i, j);
}
}
}
return unionFind.getSet();
}
5、LeetCode测试
