为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 并查集学习：从入门到初步掌握

并查集学习：从入门到初步掌握

标签：
算法与数据结构
概述

并查集是一种高效的数据结构，用于处理动态连通性问题和集合的合并查询问题。通过并查集，可以在接近常数时间内完成查找和合并操作，适用于朋友圈问题、最小生成树问题等多种应用场景。本文将带你从入门到初步掌握并查集的学习，包括其实现方式、优化技巧和典型问题的应用实例。

并查集简介

并查集的概念

并查集（Disjoint Set）是一种数据结构，用于处理一些不交集的合并及查询问题。例如，我们常常需要判断任意给出的两个元素是否在同一个集合中，或者需要对两个独立的集合进行合并。并查集支持两种基本操作：合并（Union）和查找（Find），其中查找操作用于查询两个元素是否属于同一个集合，合并操作用于合并两个集合。

并查集的主要特点是高效处理动态连通性问题，即在一个数据集合中，不断进行合并和查询操作。通过使用并查集，可以在接近常数时间内完成查找和合并操作，这对于复杂问题的解决非常有用。

并查集的应用场景

并查集的应用场景非常广泛，下面列举一些常见的应用场景：

  • 朋友圈问题：在一个社交网络中，用户与用户之间的关系可以用并查集来表示，以确定两个用户是否属于同一个朋友圈。
  • 最小生成树问题：在一个无向图中，通过并查集可以高效地找到最小生成树。
  • 图的连通性问题：判断图中两个顶点是否连通，或确定图的连通分量。
  • 集合的合并和查询：在一系列集合中进行合并和查询操作，例如在数据库系统中处理事务的依赖关系。
并查集的数据结构和基本操作

并查集的实现方式

并查集通常使用树结构来实现。每个集合用一棵树来表示，树的每个节点代表一个元素，树的根节点代表该集合的代表元素。通过维护一棵树，可以高效地完成查找和合并操作。

查找操作（Find）

查找操作用于确定元素的根节点，即确定该元素所在的集合的代表元素。可以通过递归或迭代的方式遍历树结构，找到根节点。

合并操作（Union）

合并操作用于将两个集合合并成一个集合。通过将两个集合的根节点合并，可以实现两个集合的合并。合并操作通常将较小树的根节点指向较大树的根节点，以保持树的平衡。

实例：基本并查集的实现

接下来，我们通过一个简单的例子来实现基本的并查集。这里我们使用Python来实现。

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if self.rank[rootX] > self.rank[rootY]:
            self.parent[rootY] = rootX
        elif self.rank[rootX] < self.rank[rootY]:
            self.parent[rootX] = rootY
        else:
            self.parent[rootY] = rootX
            self.rank[rootX] += 1

上述代码中，UnionFind 类包含了 find 和 union 两个方法，分别用于查找和合并操作。parent 列表表示每个元素的父节点，rank 列表表示每个元素所在树的高度。

并查集的优化技巧

路径压缩（Path Compression）

路径压缩是一种优化技术，通过递归地将每个节点指向根节点，可以减少查找操作的时间复杂度。路径压缩可以在查找操作中进行，使得每次查找操作后，树的结构变得更加扁平，从而提高查找效率。

按秩合并（Union by Rank）

按秩合并是一种优化技术，通过将较低秩的树合并到较高秩的树，可以保持树的平衡性。具体来说，如果两个树的秩相同，合并后树的秩加1；如果两个树的秩不同，将较低秩的树合并到较高秩的树。

实例：优化后的并查集实现

下面是使用路径压缩和按秩合并优化后的并查集实现。

class UnionFindOptimized:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])  # Path Compression
        return self.parent[x]

    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if self.rank[rootX] > self.rank[rootY]:
            self.parent[rootY] = rootX
        elif self.rank[rootX] < self.rank[rootY]:
            self.parent[rootX] = rootY
        else:
            self.parent[rootY] = rootX
            self.rank[rootX] += 1  # Union by Rank

上述代码中，find 方法使用了路径压缩，union 方法使用了按秩合并。

并查集的典型问题

实例分析：朋友圈问题

在社交网络中，我们可以使用并查集来确定两个用户是否属于同一个朋友圈。具体实现思路是：每次有两个用户建立关系，就将这两个用户的集合进行合并，最终可以查询任意两个用户是否属于同一个朋友圈。

代码实现

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if self.rank[rootX] > self.rank[rootY]:
            self.parent[rootY] = rootX
        elif self.rank[rootX] < self.rank[rootY]:
            self.parent[rootX] = rootY
        else:
            self.parent[rootY] = rootX
            self.rank[rootX] += 1

# 示例
n = 10  # 假设用户编号从0到9
uf = UnionFind(n)
uf.union(1, 2)
uf.union(2, 3)
uf.union(4, 5)
uf.union(6, 7)
uf.union(7, 8)
uf.union(8, 9)

print(uf.find(1) == uf.find(3))  # 输出 True，1和3属于同一个朋友圈
print(uf.find(4) == uf.find(9))  # 输出 False，4和9不属于同一个朋友圈

实例分析：最小生成树问题

最小生成树问题是图论中的一个经典问题，通过并查集可以高效地找到最小生成树。具体实现思路是：使用克鲁斯卡尔算法（Kruskal's Algorithm）或普里姆算法（Prim's Algorithm）求最小生成树，其中克鲁斯卡尔算法使用并查集来检查边是否形成环。

代码实现

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if self.rank[rootX] > self.rank[rootY]:
            self.parent[rootY] = rootX
        elif self.rank[rootX] < self.rank[rootY]:
            self.parent[rootX] = rootY
        else:
            self.parent[rootY] = rootX
            self.rank[rootX] += 1

# 示例
edges = [(0, 1, 1), (0, 2, 2), (1, 2, 3), (1, 3, 4), (2, 3, 5)]
n = 4
uf = UnionFind(n)
edges.sort(key=lambda x: x[2])  # 按照边的权重排序

mst_weight = 0
mst_edges = []
for edge in edges:
    u, v, weight = edge
    if uf.find(u) != uf.find(v):
        uf.union(u, v)
        mst_weight += weight
        mst_edges.append((u, v, weight))

print(mst_weight)  # 输出最小生成树的权重
print(mst_edges)  # 输出最小生成树的边
并查集的代码实现

Python实现并查集

前面已经详细介绍了如何使用Python实现并查集，这里再提供一个完整的Python实现。

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if self.rank[rootX] > self.rank[rootY]:
            self.parent[rootY] = rootX
        elif self.rank[rootX] < self.rank[rootY]:
            self.parent[rootX] = rootY
        else:
            self.parent[rootY] = rootX
            self.rank[rootX] += 1

这个实现中，__init__ 方法初始化并查集，find 方法查找元素的根节点，union 方法合并两个集合。

Java实现并查集

Java 实现并查集与Python类似，下面给出一个Java版本的实现。

public class UnionFind {
    private int[] parent;
    private int[] rank;

    public UnionFind(int n) {
        parent = new int[n];
        rank = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
            rank[i] = 0;
        }
    }

    public int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }

    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rank[rootX] > rank[rootY]) {
            parent[rootY] = rootX;
        } else if (rank[rootX] < rank[rootY]) {
            parent[rootX] = rootY;
        } else {
            parent[rootY] = rootX;
            rank[rootX]++;
        }
    }
}

这个实现中，UnionFind 类初始化并查集，find 方法查找元素的根节点，union 方法合并两个集合。

并查集的进阶应用

动态连通性问题

动态连通性问题是指在一个数据集合中，不断进行合并和查询操作，判断两个元素是否属于同一个集合。并查集非常适合处理动态连通性问题，因为它可以在接近常数时间内完成查找和合并操作。

代码实现

class DynamicConnectivity:
    def __init__(self, n):
        self.uf = UnionFind(n)

    def connect(self, x, y):
        return self.uf.find(x) == self.uf.find(y)

    def merge(self, x, y):
        self.uf.union(x, y)

# 示例
n = 10  # 假设用户编号从0到9
dc = DynamicConnectivity(n)
dc.merge(1, 2)
dc.merge(2, 3)
dc.merge(4, 5)
dc.merge(6, 7)
dc.merge(7, 8)
dc.merge(8, 9)

print(dc.connect(1, 3))  # 输出 True，1和3属于同一个集合
print(dc.connect(4, 9))  # 输出 False，4和9不属于同一个集合

并查集与其他算法的结合使用

并查集可以与其他算法结合使用，提高算法效率。例如，在图的最小生成树问题中，可以结合克鲁斯卡尔算法和并查集来高效地求解最小生成树。

代码实现

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if self.rank[rootX] > self.rank[rootY]:
            self.parent[rootY] = rootX
        elif self.rank[rootX] < self.rank[rootY]:
            self.parent[rootX] = rootY
        else:
            self.parent[rootY] = rootX
            self.rank[rootX] += 1

def kruskal_mst(edges, n):
    edges.sort(key=lambda x: x[2])  # 按照边的权重排序
    uf = UnionFind(n)
    mst_weight = 0
    mst_edges = []

    for edge in edges:
        u, v, weight = edge
        if uf.find(u) != uf.find(v):
            uf.union(u, v)
            mst_weight += weight
            mst_edges.append((u, v, weight))

    return mst_weight, mst_edges

# 示例
edges = [(0, 1, 1), (0, 2, 2), (1, 2, 3), (1, 3, 4), (2, 3, 5)]
n = 4
mst_weight, mst_edges = kruskal_mst(edges, n)

print(mst_weight)  # 输出最小生成树的权重
print(mst_edges)  # 输出最小生成树的边

通过上述代码，我们可以看到并查集在图的最小生成树问题中的应用，结合克鲁斯卡尔算法，可以高效地求解最小生成树。

总结

并查集作为一种高效的数据结构，能够处理动态连通性问题和集合的合并查询问题。通过对并查集的深入学习，我们可以更好地理解并查集的工作原理，并在实际编程中灵活运用。对于初学者来说，掌握并查集的基本概念和实现方式是基础，然后通过优化技巧和应用实例来进一步提升自己的编程能力。希望本文对你有所帮助，如果你想要进一步学习并查集的相关知识，推荐你访问慕课网，那里有许多优质的编程教程和实践项目。

点击查看更多内容
发表于 2024.12.25 12:27， 共 51 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

跃然一笑

手记
篇
粉丝
40
获赞与收藏
164

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消