一、概念
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。
主要构成：
并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。
数组 pre[ ] 记录了每个点的前驱节点是谁（一般理解为该点的爸爸是谁），函数 find(x) 用于查找指定节点 x 属于哪个集合（可以理解为找祖先），函数 join(x,y) 用于合并两个节点 x 和 y（一般是将x认作是y的爸爸） 。
作用：
并查集的主要作用是求连通分支数（如果一个图中所有点都存在可达关系（直接或间接相连），则此图的连通分支数为1；如果此图有两大子图各自全部可达，则此图的连通分支数为2……）。
举例：
例如一个大陆有天、地、玄、黄四个门派，每个门派有不同级别的弟子若干，pre[ ] 数组就是记录每个弟子的上司名字，而find() 方法就是找到该弟子上司的上司的上司…即所属门派的掌门人，join(A, B) 方法就是将A弟子设置为B弟子的上司。
二、python实现完整版代码
完整版的并查集数据结构有初始化、find、merge等方法，主要是方便理解，一般解题是不用完整版，因为代码量冗余增加时间空间复杂度。
class UnionFind:
def __init__(self):
self.father = {
} ##记录每个节点的父节点
def find(self, x):
root = x
while self.father[root] != root: #寻找根节点
root = self.father[root]
while root != x: #路径压缩
preFather = self.father[x]
self.father[x] = root
x = preFather
return root
def merge(self, x, y): #合并节点
root_x, root_y = self.find(x), self.find(y)
if root_x != root_y:
self.father[root_x] = root_y
def is_connected(self, x, y): #判断联通性
return self.find(x) == self.find(y)
def add(self, x): #增加节点
if x not in self.father:
self.father[x] = x
三、并查集压缩版python代码（解题最常用的写法）
解题时，为保证代码简洁，同时降低时间空间复杂度，一般只定义一个爸爸数组和一个 find() 方法。
注：该find方法具有持续更新爸爸的作用，一般以递归形式实现。
dus ={
。。。。。。} # 先定义爸爸数组的形式及初始元素值
# 定义查找祖值方法（含更新祖值作用）
def find(i):
if dus[i] != i:
dus[i] = find(dus[i])
return dus[i]
四、并查集典型例题
（一）力扣题库：947、移除最多的同行或同列石头
套用压缩版并查集模板
n 块石头放置在二维平面中的一些整数坐标点上。每个坐标点上最多只能有一块石头。
如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。
给你一个长度为 n 的数组 stones ，其中 stones[i] = [xi, yi] 表示第 i 块石头的位置，返回 可以移除的石子 的最大数量。
示例 1：
输入：stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
输出：5
解释：一种移除 5块石头的方法如下所示:
- 移除石头 [2,2] ，因为它和 [2,1] 同行。
- 移除石头 [2,1] ，因为它和 [0,1] 同列。
- 移除石头 [1,2] ，因为它和 [1,0] 同行。
- 移除石头 [1,0] ，因为它和 [0,0] 同列。
- 移除石头 [0,1] ，因为它和 [0,0] 同行。
石头 [0,0] 不能移除，因为它没有与另一块石头同行/列。
示例 2：
输入：stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
输出：3
解释：一种移除 3 块石头的方法如下所示：
- 移除石头 [2,2] ，因为它和 [2,0] 同行。
- 移除石头 [2,0] ，因为它和 [0,0] 同列。
- 移除石头 [0,2] ，因为它和 [0,0] 同行。
石头 [0,0] 和 [1,1] 不能移除，因为它们没有与另一块石头同行/列。
示例 3：
输入：stones = [[0,0]]
输出：0
解释：[0,0] 是平面上唯一一块石头，所以不可以移除它。
提示：
1 <= stones.length <= 1000
0 <= xi, yi <= 104
不会有两块石头放在同一个坐标点上
解题思路:
看完题目，第一感觉就是找出多少组连通的石头。
而每组连通的石头需要保留至少一个石头，所以答案就是石头个数-连通石头的组数。
看完官方题解之后，明白了一个技巧，把所有坐标的纵坐标加上10000（坐标的最大值），我们可以把坐标看成edges。
举一个例子，[[0,0],[1,1],[1,2]] => [[0,10000],[1,10001],[1,10002]。
这里0, 10000, 1, 10001, 10002表示5个nodes。
[0,10000]表示node 0和node 10000有edge连通。
[1,10001]表示node 1和node 10001有edge连通。
[1,10002]表示node 1和node 10002有edge连通。
这就转成熟悉的图并查集问题了，遍历所有edges，即可找出所有连通组。
时间复杂度O(nlogm)，n为edges数量，m为node数量。
空间复杂度O(m),这里使用了字典作实现并查集的，当然列表也是OK的。
此外，注意在最后要对所有node调用find，更新所属的连通组。
题解代码：
class Solution:
def removeStones(self, stones: List[List[int]]) -> int:
# 以字典形式定义初始化的parent集
dus ={
s+i*10000:s+i*10000 for stone in stones for i, s in enumerate(stone)}
print(dus)
# 定义查找祖值方法（含更新祖值作用）
def find(i):
if dus[i] != i:
dus[i] = find(dus[i])
return dus[i]
# 遍历全部石头，按顺序更新祖值
for i, (s1, s2) in enumerate(stones):
if s1 in dus and find(s1) != find(s2+10000):
# union
dus[find(s1)] = find(s2+10000)
print(i, dus)
# 防止按顺序更新的祖集中有重复未更新，再次更新
for k in dus:
print(k)
find(k)
# 最后用总数减去不重复的祖值数即可
return len(stones) - len(set(dus.values()))
（二）力扣题库：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”
解释：
交换 s[0] 和 s[3], s = “bcad”
交换 s[0] 和 s[2], s = “acbd”
交换 s[1] 和 s[2], s = “abcd”
示例 3：
输入：s = “cba”, pairs = [[0,1],[1,2]]
输出：“abc”
解释：
交换 s[0] 和 s[1], s = “bca”
交换 s[1] 和 s[2], s = “bac”
交换 s[0] 和 s[1], s = “abc”
提示：
1 <= s.length <= 10^5
0 <= pairs.length <= 10^5
0 <= pairs[i][0], pairs[i][1] < s.length
s 中只含有小写英文字母
题解思路：
主要就是考察并查集的思路，并查集使用完后，单独将每个集合包含的节点找出来，重新排序，重新赋值即可。
题解python代码（详细注释）：
# 定义一个并查集类，包含初始化祖先、查找祖先、合并祖先三种方法
class DSU:
def __init__(self, nodecount):
self.parent=[-1]*nodecount#初始化，每个节点的祖先都是自己，记住-1，这里node_count为节点总数
def findboss(self, node):# 首先，是找到自己所在集合的最上面那一层的祖先，若值不为-1，说明当前自己的祖先并不是最终祖先，循环进行再去找他的祖先，直到找到最终祖先
temp=node
while self.parent[node]!=-1:
node=self.parent[node]
if temp!=node:#路径压缩，使得所有节点的祖先都是最终的祖先
self.parent[temp]=node
return node
def mergeboss(self, node1, node2):#查询相互连通的两个人的祖先是不是同一个人
node1boss=self.findboss(node1)
node2boss=self.findboss(node2)
if node1boss!=node2boss:#如果不是，那就合并两个集合，从两人中选举一个新祖先
self.parent[node1boss]=node2boss
class Solution:
def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
n=len(s)
if n<2:
return s
dsu=DSU(n)#n个节点数，初始化并查集
for node1,node2 in pairs:#先用并查集遍历一遍，使得每个节点都找到自己的祖先
dsu.mergeboss(node1,node2)
h={
}
for i in range(n):#再将所有公共祖先的子节点划分到一起，公共祖先自己也在该集合里
if dsu.findboss(i) not in h:
h[dsu.findboss(i)]=[i]
else:
h[dsu.findboss(i)].append(i)
res=list(s)
#print(dsu.parent)
#print(h)
for nodes in h.values():
indices=sorted(nodes)#这里的每个节点都是相互连通的，即可以随意互相置换，直接按题意排序即可
string=sorted(res[node] for node in nodes)#按最小字典序排列即从小到大
# print(indices)
# print(string)
for index,letter in zip(indices,string):#按排好位置后，放回字母
res[index]=letter
return "".join(res)