首页手记并查集入门：轻松掌握并查集基础知识与应用

并查集入门：轻松掌握并查集基础知识与应用

标签：

算法与数据结构

概述

并查集是一种高效的数据结构，主要用于处理大规模数据集中的动态连通性问题。它通过高效的合并和查找操作，优化数据集的管理和操作效率。并查集在最小生成树、社区检测和图的连通性验证等多种场景中都有广泛应用。

并查集简介

并查集是一种高效的数据结构，主要用于处理大规模数据集中的动态连通性问题。它通过高效的合并和查找操作，实现对数据集的高效管理。

并查集的基本概念

并查集（Union-Find Set）主要支持两种操作：查找（Find）和合并（Union）。

查找操作（Find）：确定某一元素所在集合的标识（通常是一个父节点），并通过路径压缩优化，将查找过程中经过的每个节点直接指向根节点，以加快后续查找速度。
合并操作（Union）：将两个不同的集合合并为一个集合。一般通过将一个集合的根节点指向另一个集合的根节点来实现。

并查集的应用场景

并查集在许多实际问题中都有应用，例如：

最小生成树：并查集可以用于解决图的最小生成树问题，如Kruskal算法。
社区检测：在社交网络分析中，可以利用并查集来检测社区结构，即聚类分析。
图的连通性验证：验证图是否连通或找出所有连通分量。
网络路由：在网络路由中，可以利用并查集来管理网络中的节点和子网。
导航系统：在导航系统中，可以利用并查集来管理道路网络和道路连接情况。

并查集的优势在于其高效的查找和合并操作，这使得它在处理大规模数据集时具有非常高的效率。

并查集的数据结构

并查集支持的主要操作包括查找根节点和合并集合，为了实现这些操作，需要选择合适的数据结构。并查集通常使用数组或树结构来实现，而树结构又可以进一步优化为路径压缩和按秩合并。下面将介绍这些数据结构及其使用方法。

并查集的实现方式

常用的数据结构包括数组和树结构。数组实现简单，而树结构虽然稍微复杂一些，但能够带来更好的性能优化。

常用的数据结构介绍

数组实现

数组实现是最简单的一种方式。对于一个大小为 ( n ) 的并查集，可以使用一个数组 ( parent ) 来表示每个元素的父节点。例如，假设 ( parent[i] = j )，表示元素 ( i ) 的父节点为 ( j )。如果 ( parent[i] = i )，则表示 ( i ) 是一个根节点。

树结构实现

树结构实现引入了路径压缩和按秩合并两种优化策略，可以进一步提高查找和合并的效率。

路径压缩：在查找操作过程中，将查找路径上的所有节点直接指向根节点，从而减少未来查找操作的复杂度。
按秩合并：合并两个集合时，优先将小树的根节点指向大树的根节点，以尽量保持树的平衡性。

使用数组实现并查集

在数组实现中，我们使用一个数组 ( parent ) 来存储每个元素的父节点。数组的大小为 ( n )，表示有 ( n ) 个元素，每个元素的初始父节点都是自己。

def union_find(n):
    parent = [i for i in range(n)]
    return parent

# 示例: 创建一个包含4个元素的并查集
parent = union_find(4)
print(parent)  # 输出: [0, 1, 2, 3]

在这个例子中，union_find 函数返回一个数组 parent，初始状态下每个元素的父节点都是自己。数组的索引表示元素的编号，数组的值表示该元素的父节点编号。例如，parent[0] = 0 表示元素0的父节点是0，说明0是自己的根节点。

合并两个集合

在合并操作中，给定两个元素，我们需要将它们所在的集合合并为一个集合。如果使用数组实现，可以通过将一个集合的根节点指向另一个集合的根节点来实现。

def union(parent, x, y):
    root_x = find(parent, x)
    root_y = find(parent, y)
    parent[root_x] = root_y

# 示例: 合并元素1和元素2所在的集合
union(parent, 1, 2)
print(parent)  # 输出: [0, 2, 2, 3]

在这个例子中，union 函数将元素1和元素2所在的集合合并。合并时，只需要将一个集合的根节点指向另一个集合的根节点。

路径压缩与按秩合并优化

路径压缩是一种优化策略，用于提高查找操作的效率。在路径压缩中，每次查找一个元素时，将路径上的所有节点直接指向根节点，从而优化未来查找操作的效率。

def find_with_path_compression(parent, i):
    if parent[i] != i:
        parent[i] = find_with_path_compression(parent, parent[i])
    return parent[i]

# 示例: 使用路径压缩查找元素2的根节点
parent = union_find(4)
print(find_with_path_compression(parent, 2))  # 输出: 2

按秩合并是一种优化策略，用于提高合并操作的效率。在按秩合并中，合并两个集合时，优先将小树的根节点指向大树的根节点，以尽量保持树的平衡性。

def union_with_rank(parent, rank, x, y):
    root_x = find_with_path_compression(parent, x)
    root_y = find_with_path_compression(parent, y)
    if root_x == root_y:
        return
    if rank[root_x] < rank[root_y]:
        parent[root_x] = root_y
    elif rank[root_x] > rank[root_y]:
        parent[root_y] = root_x
    else:
        parent[root_y] = root_x
        rank[root_x] += 1

# 示例: 使用按秩合并合并元素1和元素2所在的集合
rank = [0] * 4
union_with_rank(parent, rank, 1, 2)
print(parent)  # 输出: [0, 2, 2, 3]

在这个例子中，union_with_rank 函数通过按秩合并将元素1和元素2所在的集合合并，保持树的平衡性。

并查集的常用操作

并查集的核心操作包括查找根节点和合并集合。下面详细介绍这两种操作，并解释如何使用数组和树结构实现这些操作。

查找根节点

在查找操作中，给定一个元素，我们需要找到它所在的集合的根节点。如果使用数组实现，可以通过递归地查找每个元素的父节点来实现，直到找到根节点为止。

def find(parent, i):
    if parent[i] != i:
        parent[i] = find(parent, parent[i])
    return parent[i]

# 示例: 查找元素2的根节点
parent = union_find(4)
print(find(parent, 2))  # 输出: 2

查找操作可以递归地进行，直到找到根节点为止。如果使用树结构实现，并且引入路径压缩，每次查找时，将路径上的所有节点直接指向根节点，以减少后续查找的复杂度。

合并两个集合

def union(parent, x, y):
    root_x = find(parent, x)
    root_y = find(parent, y)
    if root_x == root_y:
        return
    parent[root_x] = root_y

在这个例子中，union 函数将元素1和元素2所在的集合合并。合并时，只需要将一个集合的根节点指向另一个集合的根节点。

路径压缩与按秩合并优化

def find_with_path_compression(parent, i):
    if parent[i] != i:
        parent[i] = find_with_path_compression(parent, parent[i])
    return parent[i]

def union_with_rank(parent, rank, x, y):
    root_x = find_with_path_compression(parent, x)
    root_y = find_with_path_compression(parent, y)
    if root_x == root_y:
        return
    if rank[root_x] < rank[root_y]:
        parent[root_x] = root_y
    elif rank[root_x] > rank[root_y]:
        parent[root_y] = root_x
    else:
        parent[root_y] = root_x
        rank[root_x] += 1

在这个例子中，union_with_rank 函数通过按秩合并将元素1和元素2所在的集合合并，保持树的平衡性。

并查集的实现代码示例

并查集可以用多种编程语言实现。下面分别用Python、C++和Java三种常见语言来实现并查集，并加入路径压缩和按秩合并的优化。

Python实现并查集

在Python中，可以使用列表来表示并查集的数组和秩数组。下面是一个完整的Python实现，包括路径压缩和按秩合并的优化。

def find(parent, i):
    if parent[i] != i:
        parent[i] = find(parent, parent[i])
    return parent[i]

def union(parent, rank, x, y):
    root_x = find(parent, x)
    root_y = find(parent, y)
    if root_x == root_y:
        return
    if rank[root_x] < rank[root_y]:
        parent[root_x] = root_y
    elif rank[root_x] > rank[root_y]:
        parent[root_y] = root_x
    else:
        parent[root_y] = root_x
        rank[root_x] += 1

def union_find(n):
    parent = [i for i in range(n)]
    rank = [0] * n
    return parent, rank

# 示例
n = 10
parent, rank = union_find(n)
union(parent, rank, 1, 2)
union(parent, rank, 3, 4)
union(parent, rank, 5, 6)
union(parent, rank, 7, 8)
union(parent, rank, 9, 0)
print(find(parent, 1))  # 输出: 2
print(find(parent, 3))  # 输出: 4
print(find(parent, 5))  # 输出: 6
print(find(parent, 7))  # 输出: 8
print(find(parent, 9))  # 输出: 0

C++实现并查集

在C++中，可以使用数组来表示并查集的数组和秩数组，并使用递归和迭代两种方式实现路径压缩。

#include <vector>
#include <iostream>

class UnionFind {
public:
    UnionFind(int n) {
        parent = std::vector<int>(n);
        rank = std::vector<int>(n, 0);
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

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

    void union_set(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] += 1;
        }
    }

private:
    std::vector<int> parent;
    std::vector<int> rank;
};

int main() {
    UnionFind uf(10);
    uf.union_set(1, 2);
    uf.union_set(3, 4);
    uf.union_set(5, 6);
    uf.union_set(7, 8);
    uf.union_set(9, 0);
    std::cout << uf.find(1) << std::endl;  // 输出: 2
    std::cout << uf.find(3) << std::endl;  // 输出: 4
    std::cout << uf.find(5) << std::endl;  // 输出: 6
    std::cout << uf.find(7) << std::endl;  // 输出: 8
    std::cout << uf.find(9) << std::endl;  // 输出: 0
    return 0;
}

Java实现并查集

在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;
        }
    }

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

    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] += 1;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        UnionFind uf = new UnionFind(10);
        uf.union(1, 2);
        uf.union(3, 4);
        uf.union(5, 6);
        uf.union(7, 8);
        uf.union(9, 0);
        System.out.println(uf.find(1));  // 输出: 2
        System.out.println(uf.find(3));  // 输出: 4
        System.out.println(uf.find(5));  // 输出: 6
        System.out.println(uf.find(7));  // 输出: 8
        System.out.println(uf.find(9));  // 输出: 0
    }
}

并查集的应用案例

并查集在许多实际问题中都有广泛应用，下面通过几个典型的应用案例来说明并查集的实际用途。

最小生成树问题中的应用

最小生成树（Minimum Spanning Tree，MST）问题是指在一个连通图中找到一棵生成树，并且这棵树的边权总和最小。Kruskal算法是解决最小生成树问题的一种经典算法，它利用了并查集的思想来高效地处理连通性问题。

Kruskal算法介绍

Kruskal算法的基本步骤如下：

将所有边按权值从小到大排序。
依次选取每条边，如果这条边连接的两个顶点不在同一个集合中，则将这条边加入最小生成树，并将这两个顶点所在的集合合并。
重复步骤2，直到生成树包含图中所有顶点。

示例代码

下面是一个使用并查集实现Kruskal算法的例子。

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

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

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

def kruskal(edges, n):
    uf = UnionFind(n)
    mst = []
    edges.sort(key=lambda x: x[2])  # 按边权值排序
    for edge in edges:
        x, y, weight = edge
        if uf.find(x) != uf.find(y):
            uf.union(x, y)
            mst.append(edge)
    return mst

# 示例
edges = [(0, 1, 1), (0, 2, 2), (1, 2, 3), (1, 3, 4), (2, 3, 5)]
n = 4
print(kruskal(edges, n))  # 输出: [(0, 1, 1), (0, 2, 2), (1, 3, 4)]

在这个例子中，kruskal 函数使用并查集来实现Kruskal算法，找到图的最小生成树。

社区检测问题中的应用

在社交网络分析中，社区检测是指识别出网络中的聚类（社区）结构。通过并查集，可以高效地检测节点之间的连通性，从而实现社区检测。

社区检测算法介绍

社区检测可以通过以下步骤实现：

初始化每个节点为一个独立的社区。
依次遍历图中的每条边，如果连接的两个节点属于不同的社区，则将这两个社区合并为一个社区。
重复步骤2，直到所有的边都被处理完。

示例代码

下面是一个使用并查集实现社区检测的例子。

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

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

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

def community_detection(edges, n):
    uf = UnionFind(n)
    for edge in edges:
        uf.union(edge[0], edge[1])
    return [uf.find(i) for i in range(n)]

# 示例
edges = [(0, 1), (1, 2), (2, 3), (3, 0), (4, 5), (5, 6), (6, 4)]
n = 7
print(community_detection(edges, n))  # 输出: [0, 0, 0, 0, 4, 4, 4]

在这个例子中，community_detection 函数使用并查集来实现社区检测，识别出图中的社区结构。

图的连通性验证

在图的连通性验证中，可以通过并查集来判断一个图是否是连通图。如果所有的节点都在同一个集合中，则该图是连通图。否则，该图是不连通图。

连通性验证算法介绍

连通性验证可以通过以下步骤实现：

初始化每个节点为一个独立的集合。
遍历图中的每条边，将连接的两个节点所在的集合合并。
最后检查所有节点是否都在同一个集合中。

示例代码

下面是一个使用并查集实现图的连通性验证的例子。

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

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

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

def is_connected(edges, n):
    uf = UnionFind(n)
    for edge in edges:
        uf.union(edge[0], edge[1])
    return all(uf.find(i) == uf.find(0) for i in range(n))

# 示例
edges = [(0, 1), (1, 2), (2, 3), (3, 0)]
n = 4
print(is_connected(edges, n))  # 输出: True

edges = [(0, 1), (2, 3)]
n = 4
print(is_connected(edges, n))  # 输出: False

在这个例子中，is_connected 函数使用并查集来实现图的连通性验证，判断图是否是连通图。

并查集的进阶话题

并查集在实际应用中还有很多高级的话题可以探讨，比如如何处理加权并查集、并查集的效率分析和并查集在图论中的应用。

如何处理加权并查集

加权并查集是指并查集中的每个元素都有一个关联的权重，通常用于解决最小生成树等优化问题。处理加权并查集时，可以在并查集的数据结构中增加一个权重数组，每个元素的权重表示该元素的重要性或权重值。

加权并查集的表示

在加权并查集中，除了父节点数组和秩数组，还需要一个权重数组来存储每个元素的权重。

class WeightedUnionFind:
    def __init__(self, n):
        self.parent = [i for i in range(n)]
        self.rank = [0] * n
        self.weights = [1] * n

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

    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        if root_x != root_y:
            if self.weights[root_x] < self.weights[root_y]:
                self.parent[root_x] = root_y
                self.weights[root_y] += self.weights[root_x]
            else:
                self.parent[root_y] = root_x
                self.weights[root_x] += self.weights[root_y]

    def get_weight(self, i):
        return self.weights[self.find(i)]

在这个例子中，WeightedUnionFind 类增加了权重数组 weights 来存储每个元素的权重，并在 union 方法中更新权重。

并查集的效率分析

并查集的效率分析主要集中在查找和合并操作的复杂度上。路径压缩和按秩合并等优化策略可以显著提高并查集的效率。

路径压缩 使得查找操作的复杂度接近常数时间。
按秩合并 使得合并操作的复杂度也接近常数时间。

时间复杂度分析

通过路径压缩和按秩合并的优化，合并和查找操作的时间复杂度可以近似为 ( O(1) )。具体来说，每次查找和合并操作的复杂度可以近似为 ( O(\alpha(n)) )，其中 ( \alpha(n) ) 是阿克曼函数的反函数，增长非常缓慢。

并查集与图论的结合应用

并查集在图论中有许多应用，例如最小生成树、图的连通性验证和社区检测等。通过并查集，可以高效地处理大规模图中的连通性问题，从而解决各种实际问题。

最小生成树算法

最小生成树算法如Kruskal算法和Prim算法都可以使用并查集来实现，通过并查集来高效地处理连通性问题。

社区检测算法

社区检测算法可以通过并查集来高效地检测图中的社区结构，实现大规模社交网络的分析和聚类。

其他应用

并查集还可以用于解决图的割点问题、桥问题等，通过并查集来处理图中节点的连通性问题，从而解决各种复杂问题。

总结来说，并查集是一种非常实用且高效的抽象数据类型，广泛应用于大规模数据集的连通性问题处理中。通过路径压缩和按秩合并等优化策略，可以显著提高并查集的效率，使其在实际应用中发挥更好的作用。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕尼黑5688855

手记
篇

粉丝

8

获赞与收藏

16

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30936 346

网络编程入门教程

20个小节 12729 240

Pandas 入门教程

25个小节 18626 342

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

并查集入门：轻松掌握并查集基础知识与应用

并查集的基本概念

并查集的应用场景

并查集的实现方式

常用的数据结构介绍

数组实现

树结构实现

使用数组实现并查集

合并两个集合

路径压缩与按秩合并优化

查找根节点

合并两个集合

路径压缩与按秩合并优化

Python实现并查集

C++实现并查集

Java实现并查集

最小生成树问题中的应用

Kruskal算法介绍

示例代码

社区检测问题中的应用

社区检测算法介绍

示例代码

图的连通性验证

连通性验证算法介绍

示例代码

如何处理加权并查集

加权并查集的表示

并查集的效率分析

时间复杂度分析

并查集与图论的结合应用

最小生成树算法

社区检测算法

其他应用

阅读免费教程