并查集算法（带你了解其原理实现方法）

并查集算法是一种高效处理元素分组问题的数据结构，它通过维护一个父节点数组来实现元素的分组和合并操作。并查集算法在计算机科学中有广泛的应用，如判断无向图的连通性、判断有向图的强连通分量以及判断数组中的元素是否属于同一个子集等。通过采取一些优化措施，如路径压缩和按秩合并，可以进一步提高并查集算法的效率。

CX330的烟花

3830人浏览 · 2024-02-26 05:56:14

CX330的烟花 · 2024-02-26 05:56:14 发布

引言

并查集算法（Union-Find Algorithm）是一种非常实用的数据结构，用于处理一些元素分组的问题。它主要用于处理一些不交集的合并及查询问题。在计算机科学中，并查集算法常常用于解决连通性问题，如判断图中的两个节点是否属于同一个连通分量，或者判断一个无向图是否是连通图等。

一、并查集算法的基本思想

并查集算法的基本思想是将元素分组，每组的元素之间具有某种关系（如连通性），并且这种关系具有传递性

算法通过维护一个父节点数组来实现元素的分组，初始时每个元素的父节点都是自己。在合并两个集合时，通过修改父节点数组，将其中一个集合的根节点的父节点指向另一个集合的根节点，从而实现两个集合的合并

在查询两个元素是否属于同一个集合时，可以通过查找它们的根节点是否相同来判断。

二事例

初始化、查找、合并以及展示连通性的功能。下面是一个简单的并查集实现：

class UnionFind:
    def __init__(self, n):
        # 初始化并查集，n为元素的总数
        self.parent = list(range(n))  # 每个元素的父节点初始化为自身
        self.rank = [0] * n  # 树的秩，用于按秩合并

    def find(self, x):
        # 查找元素x的根节点（代表元素）
        if self.parent[x] != x:
            # 路径压缩，直接让x的父节点指向根节点
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        # 合并元素x和y所在的集合
        root_x = self.find(x)
        root_y = self.find(y)
        
        if root_x == root_y:
            # 如果x和y已经在同一个集合中，则不需要合并
            return

        # 按秩合并
        if self.rank[root_x] > self.rank[root_y]:
            self.parent[root_y] = root_x
        elif self.rank[root_x] < self.rank[root_y]:
            self.parent[root_x] = root_y
        else:
            # 如果秩相同，则合并时让任意一个树的秩加1
            self.parent[root_y] = root_x
            self.rank[root_x] += 1

    def is_connected(self, x, y):
        # 判断元素x和y是否属于同一个集合（即是否连通）
        return self.find(x) == self.find(y)

    def get_groups(self):
        # 获取所有的连通分量（集合）
        groups = {}
        for i in range(len(self.parent)):
            root = self.find(i)
            if root not in groups:
                groups[root] = []
            groups[root].append(i)
        return groups

# 示例
if __name__ == "__main__":
    uf = UnionFind(5)  # 创建一个包含5个元素的并查集

    print(uf.is_connected(0, 1))  # 初始时，所有元素都是孤立的，因此输出False

    uf.union(0, 1)  # 合并元素0和1所在的集合
    uf.union(1, 2)  # 合并元素1和2所在的集合
    uf.union(3, 4)  # 合并元素3和4所在的集合

    print(uf.is_connected(0, 2))  # 0和2现在属于同一个集合，因此输出True
    print(uf.is_connected(0, 3))  # 0和3属于不同的集合，因此输出False

    print(uf.get_groups())  # 输出所有的连通分量（集合）

在这个示例中，UnionFind 类提供了以下功能：

__init__：初始化并查集，为每个元素分配一个父节点，并初始化秩数组。
find：查找元素x的根节点（代表元素），并执行路径压缩优化。
union：合并元素x和y所在的集合，使用按秩合并策略来优化树的高度。
is_connected：判断元素x和y是否属于同一个集合，即它们是否连通。
get_groups：获取所有的连通分量（集合），以字典形式返回，其中键是代表元素，值是该集合中的元素列表

三、并查集算法的应用

并查集算法在计算机科学中有许多应用，以下是一些典型的应用场景：

1 判断无向图的连通性：

将无向图中的节点作为并查集的元素，如果两个节点之间有边相连，则将它们所属的集合合并。最终，如果所有节点都属于同一个集合，则图是连通的；否则，图是非连通的。

2 判断有向图的强连通分量：

将有向图中的节点作为并查集的元素，从任意节点开始进行深度优先搜索，将搜索到的节点标记为已访问，并将它们的父节点指向同一个根节点。搜索结束后，每个根节点所代表的节点集合就是一个强连通分量。

3 判断数组中的元素是否属于同一个子集：

将数组中的元素作为并查集的元素，如果两个元素满足某种条件（如相等或具有某种特定关系），则将它们所属的集合合并。最终，可以判断任意两个元素是否属于同一个子集。

四操作方法

在并查集算法中，基本的操作包括查找（find）、合并（union）以及检查两个元素是否连通（is_connected）。下面是对这些操作更详细的解释：

1 查找

查找操作用于确定元素 x 的根节点（即代表元素）。在并查集中，每个元素都通过树结构连接到它的根节点。查找操作通常还包含路径压缩的优化，它直接将元素 x 的父节点设置为根节点，从而减少未来查找操作所需的时间。

def find(self, x):
    if self.parent[x] != x:
        self.parent[x] = self.find(self.parent[x])  # 路径压缩
    return self.parent[x]

2 合并

合并操作用于将两个元素 x 和 y 所在的集合合并成一个集合。首先，需要找到 x 和 y 的根节点（代表元素）。然后，根据两个集合的秩（rank）来决定如何合并它们。通常，将秩较小的树合并到秩较大的树中，如果两个树的秩相同，则可以选择任意一个作为新树的根，并将它的秩加 1。

def union(self, x, y):
    root_x = self.find(x)
    root_y = self.find(y)
    
    if root_x == root_y:
        return  # x 和 y 已经在同一个集合中，不需要合并

    # 按秩合并
    if self.rank[root_x] > self.rank[root_y]:
        self.parent[root_y] = root_x
    elif self.rank[root_x] < self.rank[root_y]:
        self.parent[root_x] = root_y
    else:
        self.parent[root_y] = root_x
        self.rank[root_x] += 1

3 获取连通分量（get_groups）

获取连通分量操作用于获取并查集中所有的连通分量（即集合）。它通过遍历所有元素，找到每个元素的根节点，并将根节点相同的元素归为一组。

def get_groups(self):
    groups = {}
    for i in range(len(self.parent)):
        root = self.find(i)
        if root not in groups:
            groups[root] = []
        groups[root].append(i)
    return groups