👋 大家好，欢迎来到我的技术博客！
💻 作为一名热爱 Java 与软件开发的程序员，我始终相信：清晰的逻辑 + 持续的积累 = 稳健的成长。
📚 在这里，我会分享学习笔记、实战经验与技术思考，力求用简单的方式讲清楚复杂的问题。
🎯 本文将围绕数据结构与算法这个话题展开，希望能为你带来一些启发或实用的参考。
🌱 无论你是刚入门的新手，还是正在进阶的开发者，希望你都能有所收获！
文章目录
🔗 数据结构与算法：无向图的连通性 —— 并查集的应用场景 🌐
在现实世界中，我们常常需要判断“两个事物是否属于同一个群体”或“它们之间是否存在连接路径”。例如：
- 在社交网络中，两个人是否通过好友链相连？ 🤝
- 在计算机网络中，两台主机是否处于同一个局域网？ 🖥️
- 在图像处理中，两个像素是否属于同一个连通区域？ 🖼️
- 在动态图中，新增一条边是否会形成环？ 🔁
这些问题本质上都是在询问图的连通性（Connectivity）。对于一个无向图，如果任意两个顶点之间都存在路径，则称该图为连通图；否则，它由多个连通分量（Connected Components） 组成。
传统的图遍历方法（如 DFS 或 BFS）可以解决连通性问题，但当图是动态变化的（不断添加边），并且需要频繁查询两个节点是否连通时，它们的效率就显得捉襟见肘了。
这时，一个优雅而高效的数据结构登场了——并查集（Union-Find Data Structure），也被称为不相交集合（Disjoint Set Union, DSU）。
本文将深入探讨并查集的原理、实现、优化技巧，并结合 Java 代码示例 💻、Mermaid 图表 📊 和 可访问的权威参考资料 🔗，带你全面掌握这一解决连通性问题的利器。
🧩 什么是并查集？
并查集是一种用于管理元素分组的数据结构。它支持两种核心操作：
- 查找（Find）：确定某个元素属于哪个集合（组）。通常通过返回该集合的“代表元”（如根节点）来实现。
- 合并（Union）：将两个不同的集合合并为一个集合。
并查集特别适合处理动态连通性问题，即在图的边不断添加的过程中，快速判断任意两个顶点是否连通。
📦 核心思想
- 每个集合用一棵树来表示。
- 树的根节点作为该集合的“代表元”。
- 查找操作：从节点向上遍历到根节点。
- 合并操作：将一棵树的根节点连接到另一棵树的根节点上。
💻 Java 实现：基础并查集
public class UnionFind {
private int[] parent; // parent[i] 表示节点 i 的父节点
private int[] rank; // 用于按秩合并的优化
private int count; // 连通分量的数量
public UnionFind(int n) {
this.count = n;
this.parent = new int[n];
this.rank = new int[n];
// 初始化：每个节点的父节点是自己，形成 n 个单元素集合
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
// 查找：返回节点 x 所在集合的根节点（代表元）
public int find(int x) {
if (parent[x] != x) {
parent[x] = find(parent[x]); // 路径压缩（优化）
}
return parent[x];
}
// 合并：将包含 x 和 y 的两个集合合并
public void union(int x, int y) {
int rootX = find(x);
int rootY = find(y);
if (rootX == rootY) {
return; // 已经在同一个集合中
}
// 按秩合并：将秩小的树合并到秩大的树下
if (rank[rootX] < rank[rootY]) {
parent[rootX] = rootY;
} else if (rank[rootX] > rank[rootY]) {
parent[rootY] = rootX;
} else {
parent[rootY] = rootX;
rank[rootX]++;
}
count--; // 合并后，连通分量数量减一
}
// 判断 x 和 y 是否在同一个集合中
public boolean connected(int x, int y) {
return find(x) == find(y);
}
// 返回当前连通分量的数量
public int getCount() {
return count;
}
}
🔍 代码解析
parent[]数组：存储每个节点的父节点。parent[i] == i表示i是根节点。rank[]数组：存储树的“秩”（近似高度），用于按秩合并（Union by Rank） 优化，防止树退化成链表。find方法：递归查找根节点，并通过路径压缩（Path Compression） 优化，将查找路径上的所有节点直接连接到根节点，大幅降低后续查找时间。union方法：先查找两个节点的根，如果不同，则合并。按秩合并确保树的高度尽可能小。
🎨 可视化并查集操作
让我们通过一个例子，可视化并查集的操作过程。
graph TD
subgraph 初始化 (6个节点)
A((0)):::root
B((1)):::root
C((2)):::root
D((3)):::root
E((4)):::root
F((5)):::root
style A fill:#69f,stroke:#333,color:#fff
style B fill:#69f,stroke:#333,color:#fff
style C fill:#69f,stroke:#333,color:#fff
style D fill:#69f,stroke:#333,color:#fff
style E fill:#69f,stroke:#333,color:#fff
style F fill:#69f,stroke:#333,color:#fff
classDef root fill:#69f,stroke:#333,color:#fff
classDef normal fill:#fff,stroke:#333
end
subgraph 执行 union(0,1)
A2((0)):::root
B2((1)):::normal
A2 --> B2
style A2 fill:#69f,stroke:#333,color:#fff
style B2 fill:#fff,stroke:#333
end
subgraph 执行 union(2,3)
C2((2)):::root
D2((3)):::normal
C2 --> D2
style C2 fill:#69f,stroke:#333,color:#fff
style D2 fill:#fff,stroke:#333
end
subgraph 执行 union(0,2)
A3((0)):::root
B3((1)):::normal
C3((2)):::normal
D3((3)):::normal
A3 --> B3
A3 --> C3
C3 --> D3
style A3 fill:#69f,stroke:#333,color:#fff
style B3 fill:#fff,stroke:#333
style C3 fill:#fff,stroke:#333
style D3 fill:#fff,stroke:#333
end
click A "https://en.wikipedia.org/wiki/Disjoint-set_data_structure" "Union-Find - Wikipedia"
操作序列：
- 初始化：6 个独立的集合。
union(0,1)：将 0 和 1 合并，0 为根。union(2,3)：将 2 和 3 合并，2 为根。union(0,2)：将两个集合合并，0 为根，2 成为 0 的子节点。
此时，{0,1,2,3} 属于同一个连通分量，{4}, {5} 各自独立。
⚡ 优化技巧：路径压缩与按秩合并
并查集的高效性来自于两大优化：
1. 🔄 路径压缩（Path Compression）
在 find 操作中，将查找路径上的所有节点直接连接到根节点。
效果：后续查找该路径上任何节点的时间接近 O(1)。
public int find(int x) {
if (parent[x] != x) {
parent[x] = find(parent[x]); // 递归并压缩路径
}
return parent[x];
}
2. 📏 按秩合并（Union by Rank）
在 union 操作中，将秩（高度）小的树合并到秩大的树下。
效果：防止树过高，保持较低的查找时间。
if (rank[rootX] < rank[rootY]) {
parent[rootX] = rootY;
} else if (rank[rootX] > rank[rootY]) {
parent[rootY] = rootX;
} else {
parent[rootY] = rootX;
rank[rootX]++;
}
📈 时间复杂度分析
经过路径压缩和按秩合并优化后，并查集的摊还时间复杂度接近 O(α(n))，其中 α(n) 是反阿克曼函数。
α(n)增长极其缓慢，对于任何实际应用中的n，α(n) ≤ 4。- 因此，并查集的操作可以视为几乎常数时间。
🛠️ 应用场景：并查集的实际用途
1. 🧩 判断无向图的连通性
给定一个无向图，判断它是否连通，或找出所有连通分量。
public boolean isGraphConnected(int n, int[][] edges) {
UnionFind uf = new UnionFind(n);
for (int[] edge : edges) {
uf.union(edge[0], edge[1]);
}
return uf.getCount() == 1; // 连通分量数量为1
}
2. 🔁 检测图中的环
在添加边的过程中，如果 find(u) == find(v)，说明 u 和 v 已连通，再添加边 (u,v) 会形成环。
public boolean hasCycle(int n, int[][] edges) {
UnionFind uf = new UnionFind(n);
for (int[] edge : edges) {
int u = edge[0], v = edge[1];
if (uf.connected(u, v)) {
return true; // 发现环
}
uf.union(u, v);
}
return false;
}
3. 🏗️ 最小生成树（Kruskal 算法）
Kruskal 算法按边权重排序，依次选择不形成环的边。并查集用于高效检测环。
public int kruskalMST(int n, List<Edge> edges) {
Collections.sort(edges); // 按权重排序
UnionFind uf = new UnionFind(n);
int mstWeight = 0;
for (Edge e : edges) {
if (!uf.connected(e.u, e.v)) {
uf.union(e.u, e.v);
mstWeight += e.weight;
}
}
return mstWeight;
}
4. 🧩 岛屿数量（LeetCode 200）
将二维网格中的相邻陆地合并，最终的连通分量数量就是岛屿数量。
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) return 0;
int m = grid.length, n = grid[0].length;
UnionFind uf = new UnionFind(m * n);
int water = 0;
int[][] dirs = {{1,0}, {0,1}};
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == '0') {
water++;
} else {
for (int[] dir : dirs) {
int ni = i + dir[0], nj = j + dir[1];
if (ni < m && nj < n && grid[ni][nj] == '1') {
uf.union(i * n + j, ni * n + nj);
}
}
}
}
}
return uf.getCount() - water;
}
🔗 权威参考资料（可访问）
-
📘 维基百科 - 不相交集合
详细介绍并查集的原理、优化和复杂度分析。 -
📚 GeeksforGeeks - Union-Find Algorithm
包含多种应用场景的代码实现。 -
🎓 USFCA 可视化 - Union-Find
交互式动画，直观理解连通分量的动态合并。 -
🧪 Khan Academy - 并查集
免费课程，适合初学者学习图算法。
🚀 总结
并查集是解决动态连通性问题的利器。它通过查找（Find） 和 合并（Union） 两个操作，高效地管理元素的分组关系。
- 核心优化：路径压缩 + 按秩合并，使操作接近常数时间。
- 适用场景：连通性判断、环检测、Kruskal 算法、岛屿问题等。
- 优势：代码简洁，效率极高，特别适合边动态添加的场景。
掌握并查集，你将拥有一把解决复杂连通性问题的“瑞士军刀”。在算法竞赛和实际工程中，它都是不可或缺的工具。继续探索，你会发现更多数据结构的精妙之处！✨
🙌 感谢你读到这里！
🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近你与目标的距离。
💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享 给更多需要的朋友！
💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿
🔔 关注我，不错过下一篇干货！我们下期再见！✨
扫一扫
1576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
