数据结构-并查集

原创已于 2026-07-22 20:09:47 修改 · 381 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

数据结构

于 2026-07-22 19:55:38 首次发布

个人主页：

个人专栏：

座右铭：

等风来不如追风去，追寻的过程就是人生的意义。

一、并查集的概念

二、并查集的实现

三、性能优化

一、并查集的概念

并查集（Disjoint Set Union，简称 DSU，也叫 Union-Find）是一种树形的数据结构，用来高效地处理元素的分组问题。它主要支持两种操作：

合并（Union）：将两个元素所在的集合合并成一个集合。
查询（Find）：查找某个元素属于哪个集合（通常返回该集合的“根节点”）。

比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，武汉招3人，10个人来自不

同的学校，起先互不相识，每个学生都是一个独立的小团体，现给这些学生进行编号：{0, 1, 2, 3,

4, 5, 6, 7, 8, 9}; 给以下数组用来存储该小集体，数组中的数字代表：该小集体中具有成员的个

数。(负号下文解释)

毕业后，学生们要去公司上班，每个地方的学生自发组织成小分队一起上路，于是：

西安学生小分队s1={0,6,7,8}，成都学生小分队s2={1,4,9}，武汉学生小分队s3={2,3,5}就相互认识

了，10个人形成了三个小团体。假设右三个群主0,1,2担任队长，负责大家的出行。

一趟火车之旅后，每个小分队成员就互相熟悉，称为了一个朋友圈。

从上图可以看出：编号6,7,8同学属于0号小分队，该小分队中有4人(包含队长0)；编号为4和9的同

学属于1号小分队，该小分队有3人(包含队长1)，编号为3和5的同学属于2号小分队，该小分队有3

个人(包含队长1)。

仔细观察数组中内融化，可以得出以下结论：

1. 数组的下标对应集合中元素的编号

2. 数组中如果为负数，负号代表根，数字代表该集合中元素个数

3. 数组中如果为非负数，代表该元素双亲在数组中的下标

在公司工作一段时间后，西安小分队中8号同学与成都小分队1号同学奇迹般的走到了一起，两个

小圈子的学生相互介绍，最后成为了一个小圈子：

现在0集合有7个人，2集合有3个人，总共两个朋友圈。

通过以上例子可知，并查集一般可以解决一下问题：

1. 查找元素属于哪个集合

沿着数组表示树形关系以上一直找到根(即：树中中元素为负数的位置)

2. 查看两个元素是否属于同一个集合

沿着数组表示的树形关系往上一直找到树的根，如果根相同表明在同一个集合，否则不在

3. 将两个集合归并成一个集合

将两个集合中的元素合并

将一个集合和另一个集合合并

4. 集合的个数

遍历数组，数组中元素为负数的个数即为集合的个数。

二、并查集的实现

并查集的逻辑结构是由多颗树组成的森林，但在实现上我们用数组来模拟并查集的逻辑结构。

1. 数组的下标对应集合中元素的编号

2. 数组中如果为负数，负号代表根，数字代表该集合中元素个数

3. 数组中如果为非负数，代表该元素双亲在数组中的下标

完整实现代码：

class DSU {
private:
    std::vector<int> parent; // parent[i] < 0 表示 i 是根，其绝对值是集合大小
public:
    DSU(int n) {
        parent.resize(n + 1, -1); // 下标 0 不用，1~n 初始大小为 -1
                                  // 表示一开始每个元素都是单独的一个集合，集合大小为1
    }

    // 查找根
    int find(int x) {
        while (parent[x] >= 0) {  // 不是根
            x = parent[x];
        }
        return x;
    }

    // 合并
    void unite(int x, int y) {
        int rx = find(x);
        int ry = find(y);
        if (rx == ry) return;
        parent[rx] += parent[ry]; // 更新大小（负数相加）
        parent[ry] = rx;          // 将 ry 的根指向 rx
    }
    
    //判断两个元素是否属于同一个集合
    bool connected(int x, int y) {
        return find(x) == find(y);
    }
    
    //元素所处集合的元素个数
    int getSize(int x) {
        int r = find(x);
        return -parent[r];
    }
};

三、性能优化

如果不加优化，极端情况下经过数次合并操作树会变得很高（像一条链），Find 操作要不断循环找到根节点，速度就会变慢，最坏情况可能退化成一条长长的链，导致 O(N)

为此，我们可以执行两个关键优化

路径压缩（Path Compression）
在执行 Find 时，顺带把沿途经过的所有节点直接挂到根节点下面，让树变得扁平。这样以后查找就很快了。
按秩合并（Union by Rank/Size）
在合并时，将“矮”的树（或元素少的树）挂到“高”的树（或元素多的树）下面，因为挂在下面的树相当于每个元素的高度+1，查找时就要多一次递归或循环，那我们肯定希望尽可能少的元素高度增加。通常用 rank（高度）或 size（节点数量）来作为判断依据。

同时使用这两种优化后，单次操作的平均时间复杂度为 O(α(n))，其中 α(n) 是反阿克曼函数，增长极其缓慢，对于任何正常数据范围都可以近似认为是 O(1) 的常数时间。

优化实现代码：

class DSU {
private:
    std::vector<int> parent;
public:
    DSU(int n) {
        parent.resize(n + 1, -1);
    }

    // 查找根（带路径压缩，递归版）
    int find(int x) {
        if (parent[x] < 0) return x;        // 自己是根
        return parent[x] = find(parent[x]); // 递归压缩
    }

    // 合并（按大小）
    void unite(int x, int y) {
        int rx = find(x);
        int ry = find(y);
        if (rx == ry) return;

        // 按大小合并
        if (parent[rx] > parent[ry]) { // 注意：负数比较，如 -3 > -5 表示 rx 更小
            std::swap(rx, ry);
        }
        parent[rx] += parent[ry];
        parent[ry] = rx;
    }

    bool connected(int x, int y) {
        return find(x) == find(y);
    }

    int getSize(int x) {
        int r = find(x);
        return -parent[r];
    }
};

关键点说明：

根节点标识：parent[root] < 0，绝对值就是集合大小。

非根节点：parent[node] 存储其父节点下标（非负）。

按大小合并：比较 parent[rx] 和 parent[ry] 的大小（注意负数），让值更小的（即绝对值更大的）作为新根，保证树的高度不超过 O(log N)。

路径压缩：find 递归时直接将沿途节点挂到根上，极大加速后续查找。