并查集算法：Python实现与工程实践指南

"在计算机科学中，高效管理动态连通性问题是许多复杂系统的核心挑战。并查集算法以其简洁优雅的设计，成为解决这类问题的瑞士军刀。"

引言：连通性问题的重要性

在现实世界和计算机科学中，连通性问题无处不在：

• 社交网络：判断两个人是否属于同一个朋友圈

• 电路设计：检测电路中的短路问题

• 图像处理：识别连通区域

• 网络连接：判断计算机节点间的连通性

• 游戏开发：迷宫生成与路径检测

并查集（Union-Find）算法正是为解决这类动态连通性问题而生的高效数据结构。本文将深入探讨并查集的原理、Python实现、优化技巧以及实际工程应用。

一、并查集基础概念

1.1 并查集核心操作

并查集支持三种基本操作：

1. 初始化（Initialize）：创建包含n个独立集合的数据结构

2. 合并（Union）：将两个集合合并为一个

3. 查找（Find）：确定元素属于哪个集合，通常返回集合的代表元素

class UnionFind:def __init__(self, n):"""初始化并查集"""self.parent = list(range(n))  # 父节点指针self.rank = [0] * n          # 树的高度def find(self, x):"""查找元素x的根节点"""passdef union(self, x, y):"""合并元素x和y所在的集合"""pass

1.2 并查集的应用场景

应用领域	具体问题	并查集作用
社交网络	朋友圈检测	动态合并好友关系
图像处理	连通区域标记	合并相邻像素
网络连接	网络连通性检测	管理网络节点
游戏开发	迷宫生成与求解	检测路径连通
编译器设计	变量等价类	合并等价变量

二、并查集的Python实现

2.1 基础实现（Quick Find）

class QuickFindUF:"""快速查找实现（数组存储集合ID）"""def __init__(self, n):self.id = list(range(n))  # 每个元素的集合IDdef find(self, p):"""O(1)时间复杂度"""return self.id[p]def union(self, p, q):"""O(n)时间复杂度"""pid = self.id[p]qid = self.id[q]# 如果已经在同一集合，直接返回if pid == qid:return# 将所有属于p集合的元素改为q的集合IDfor i in range(len(self.id)):if self.id[i] == pid:self.id[i] = qiddef connected(self, p, q):"""检查p和q是否连通"""return self.find(p) == self.find(q)

特点分析：

• 查找操作高效（O(1)）

• 合并操作代价高（O(n)）

• 适合查找多、合并少的场景

2.2 树形实现（Quick Union）

class QuickUnionUF:"""树形结构实现"""def __init__(self, n):self.parent = list(range(n))  # 父节点指针def find(self, p):"""O(tree height)时间复杂度"""# 沿着父指针向上查找，直到根节点while p != self.parent[p]:p = self.parent[p]return pdef union(self, p, q):"""O(tree height)时间复杂度"""root_p = self.find(p)root_q = self.find(q)if root_p == root_q:return# 将一棵树连接到另一棵树的根节点self.parent[root_p] = root_qdef connected(self, p, q):return self.find(p) == self.find(q)

特点分析：

• 查找和合并都是O(h)复杂度，h为树高

• 最坏情况下树可能退化为链表（h=n）

• 需要优化树结构以提高效率

三、并查集优化策略

3.1 按秩合并（Union by Rank）

class UnionByRankUF:"""按秩合并优化"""def __init__(self, n):self.parent = list(range(n))self.rank = [0] * n  # 树的高度初始为0def find(self, p):while p != self.parent[p]:p = self.parent[p]return pdef union(self, p, q):root_p = self.find(p)root_q = self.find(q)if root_p == root_q:return# 将矮树合并到高树if self.rank[root_p] < self.rank[root_q]:self.parent[root_p] = root_qelif self.rank[root_p] > self.rank[root_q]:self.parent[root_q] = root_pelse:# 高度相同时，任意合并，但高度增加1self.parent[root_q] = root_pself.rank[root_p] += 1

优化效果：

• 保证树的高度不超过O(log n)

• 查找和合并操作时间复杂度为O(log n)

3.2 路径压缩（Path Compression）

class PathCompressionUF:"""路径压缩优化"""def __init__(self, n):self.parent = list(range(n))def find(self, p):# 递归实现路径压缩if self.parent[p] != p:self.parent[p] = self.find(self.parent[p])return self.parent[p]def union(self, p, q):root_p = self.find(p)root_q = self.find(q)if root_p == root_q:returnself.parent[root_q] = root_p

优化效果：

• 在查找过程中将节点直接连接到根节点

• 摊还时间复杂度接近O(α(n))，其中α是反阿克曼函数

3.3 完整优化实现（按秩合并 + 路径压缩）

class OptimizedUnionFind:"""完全优化的并查集实现"""def __init__(self, n):self.parent = list(range(n))self.rank = [0] * nself.count = n  # 连通分量数量def find(self, p):# 迭代路径压缩while p != self.parent[p]:# 路径压缩：将p的父节点指向祖父节点self.parent[p] = self.parent[self.parent[p]]p = self.parent[p]return pdef union(self, p, q):root_p = self.find(p)root_q = self.find(q)if root_p == root_q:return# 按秩合并if self.rank[root_p] < self.rank[root_q]:self.parent[root_p] = root_qelif self.rank[root_p] > self.rank[root_q]:self.parent[root_q] = root_pelse:self.parent[root_q] = root_pself.rank[root_p] += 1self.count -= 1  # 连通分量减少def connected(self, p, q):return self.find(p) == self.find(q)def component_count(self):"""返回连通分量数量"""return self.count

时间复杂度：

• 构造函数：O(n)

• 合并操作：O(α(n))（摊还时间）

• 查找操作：O(α(n))（摊还时间）

• 连通性检查：O(α(n))（摊还时间）

其中α(n)是增长极其缓慢的反阿克曼函数，对于所有实际应用场景，α(n) < 5。

四、并查集性能对比

4.1 时间复杂度对比

实现方式	初始化	查找	合并	连通性检查	最坏情况
快速查找	O(n)	O(1)	O(n)	O(1)	O(n²)
快速合并	O(n)	O(n)	O(n)	O(n)	O(n²)
按秩合并	O(n)	O(log n)	O(log n)	O(log n)	O(n log n)
路径压缩	O(n)	O(α(n))	O(α(n))	O(α(n))	O(α(n))
完全优化	O(n)	O(α(n))	O(α(n))	O(α(n))	O(α(n))