并查集

最新推荐文章于 2024-07-15 18:06:38 发布

哈哈coding

最新推荐文章于 2024-07-15 18:06:38 发布

阅读量209

点赞数

分类专栏：算法与数据结构文章标签：算法面试数据结构

本文链接：https://blog.csdn.net/qq_34731182/article/details/114451655

版权

算法与数据结构专栏收录该内容

14 篇文章 1 订阅

订阅专栏

本文详细介绍了并查集这一数据结构，包括其基本概念、两种主要实现方式QuickFind和QuickUnion，以及针对这两者的优化策略，如基于size的优化、基于rank的优化和路径压缩。通过这些优化，提高了查找和连接操作的效率，降低了树的高度，确保了并查集在处理大规模数据连接问题时的性能。

摘要由CSDN通过智能技术生成

并查集

文章目录

并查集

概述

并查集用来解决连接问题
对于一组数据，主要支持两个操作：
- union(p,q)：将p和q连接起来
- find(p)：查p具体是在哪个组中
- 以上两个操作用来回到isConnected(p,q)：判断p、q是否相连

基本数据表示

Quick Find

用一个数组表示每个数据的连接关系，其中数组中的每个元素是该数据所属的组。如上图所示，编号为0的元素相连，编号为1的元素相连。
对于Find操作，也就是查看某个元素所属的组的操作，只需返回其id号即可，非常快速，因此该种数据表示方法称为Quick Find。时间复杂度为O(1)
但是对于Union操作并不方便，比如若将1和2连接起来，则需要遍历一遍数组，要么将所有编号为0的改为1，要么将所有编号为1的改为0。时间复杂度为O(n)

class QuickFind {

private:
    int *id;    // 我们的第一版Union-Find本质就是一个数组
    int count;  // 数据个数

public:
    // 构造函数
    UnionFind(int n) {
        count = n;
        id = new int[n];
        // 初始化, 每一个id[i]指向自己, 没有合并的元素
        for (int i = 0; i < n; i++)
            id[i] = i;
    }

    // 析构函数
    ~UnionFind() {
        delete[] id;
    }

    // 查找过程, 查找元素p所对应的集合编号
    int find(int p) {
        assert(p >= 0 && p < count);
        return id[p];
    }

    // 查看元素p和元素q是否所属一个集合
    // O(1)复杂度
    bool isConnected(int p, int q) {
        return find(p) == find(q);
    }

    // 合并元素p和元素q所属的集合
    // O(n) 复杂度
    void unionElements(int p, int q) {

        int pID = find(p);
        int qID = find(q);

        if (pID == qID)
            return;

        // 合并过程需要遍历一遍所有元素, 将两个元素的所属集合编号合并
        for (int i = 0; i < count; i++)
            if (id[i] == pID)
                id[i] = qID;
    }
};

Quick Union

该种表示方法将每个元素看做为一个节点。每个元素指向其父节点，若该节点为根节点，则其指向自己。
对于Union操作，也就是将两个元素连接起来，只需将其中一个元素的根节点指向另一个元素的根节点即可，比较方便，因此称为Quick Union。时间复杂度为O(h)，h为树的高度
对于Find操作，也就是查找某个节点所属的组，需要不断递归找到其相连的根节点。时间复杂度同样为O(h)
上述模型同样可以使用数组来实现，其中每个元素存储器对应的父节点

class UnionFind{

private:
    // 我们的第二版Union-Find, 使用一个数组构建一棵指向父节点的树
    // parent[i]表示第i个元素所指向的父节点
    int* parent;
    int count;  // 数据个数

public:
    // 构造函数
    UnionFind(int count){
        parent = new int[count];
        this->count = count;
        // 初始化, 每一个parent[i]指向自己, 表示每一个元素自己自成一个集合
        for( int i = 0 ; i < count ; i ++ )
            parent[i] = i;
    }

    // 析构函数
    ~UnionFind(){
        delete[] parent;
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    int find(int p){
        assert( p >= 0 && p < count );
        // 不断去查询自己的父亲节点, 直到到达根节点
        // 根节点的特点: parent[p] == p
        while( p != parent[p] )
            p = parent[p];
        return p;
    }

    // 查看元素p和元素q是否所属一个集合
    // O(h)复杂度, h为树的高度
    bool isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合并元素p和元素q所属的集合
    // O(h)复杂度, h为树的高度
    void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        parent[pRoot] = qRoot;
    }
};

优化

基于size的优化

在将两个节点连接时，容易将节点数多的组连接到节点数少的组上，这样导致生成的集合会很长。如下图所示：
当进行union(4,9)操作时，理想情况是将节点9连到4的根节点8上，但却有可能会出现节点8连到节点9上，导致生成的这个集合层数较高，在查找底层节点时会消耗更多的时间
因此需要存储每个集合的节点数量，在进行union操作时，将节点少的集合连接到节点多大的集合上

class UnionFind{
private:
    int* parent; // parent[i]表示第i个元素所指向的父节点
    int* sz;     // sz[i]表示以i为根的集合中元素个数
    int count;   // 数据个数

public:
    // 构造函数
    UnionFind(int count){
        parent = new int[count];
        sz = new int[count];
        this->count = count;
        for( int i = 0 ; i < count ; i ++ ){
            parent[i] = i;
            sz[i] = 1;
        }
    }

    // 析构函数
    ~UnionFind(){
        delete[] parent;
        delete[] sz;
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    int find(int p){
        assert( p >= 0 && p < count );
        // 不断去查询自己的父亲节点, 直到到达根节点
        // 根节点的特点: parent[p] == p
        while( p != parent[p] )
            p = parent[p];
        return p;
    }

    // 查看元素p和元素q是否所属一个集合
    // O(h)复杂度, h为树的高度
    bool isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合并元素p和元素q所属的集合
    // O(h)复杂度, h为树的高度
    void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        // 根据两个元素所在树的元素个数不同判断合并方向
        // 将元素个数少的集合合并到元素个数多的集合上
        if( sz[pRoot] < sz[qRoot] ){
            parent[pRoot] = qRoot;
            sz[qRoot] += sz[pRoot];
        }
        else{
            parent[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }
};

基于rank的优化

考虑到一个节点数少的集合其层数有可能更多，而一个节点数多的集合其层数有可能少。因此，仅仅基于集合中节点的个数来作为合并的依据并不完全准确，而应该基于集合所代表的的树的层数。如下图所示，虽然以节点7为根的集合的节点数多于以节点8为根的集合，但在进行union(7,8)操作时，应将节点7连到节点8上，而不是相反。

class UnionFind{

private:
    int* rank;   // rank[i]表示以i为根的集合所表示的树的层数
    int* parent; // parent[i]表示第i个元素所指向的父节点
    int count;   // 数据个数

public:
    // 构造函数
    UnionFind(int count){
        parent = new int[count];
        rank = new int[count];
        this->count = count;
        for( int i = 0 ; i < count ; i ++ ){
            parent[i] = i;
            rank[i] = 1;
        }
    }

    // 析构函数
    ~UnionFind(){
        delete[] parent;
        delete[] rank;
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    int find(int p){
        assert( p >= 0 && p < count );
        // 不断去查询自己的父亲节点, 直到到达根节点
        // 根节点的特点: parent[p] == p
        while( p != parent[p] )
            p = parent[p];
        return p;
    }

    // 查看元素p和元素q是否所属一个集合
    // O(h)复杂度, h为树的高度
    bool isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合并元素p和元素q所属的集合
    // O(h)复杂度, h为树的高度
    void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        // 根据两个元素所在树的元素个数不同判断合并方向
        // 将元素个数少的集合合并到元素个数多的集合上
        if( rank[pRoot] < rank[qRoot] ){
            parent[pRoot] = qRoot;
        }
        else if( rank[qRoot] < rank[pRoot]){
            parent[qRoot] = pRoot;
        }
        else{ // rank[pRoot] == rank[qRoot]
            parent[pRoot] = qRoot;
            rank[qRoot] += 1;   // 此时, 我维护rank的值
        }
    }
};

路径压缩

路径压缩是对find过程进行优化
之前的find过程需要不断遍历其父亲节点直到遇到根节点，这对于层数较高的节点来说会消耗较多时间，如下图中，若要find(4)，则需要不断遍历
路径压缩是在find的过程中不断地让该节点指向其父亲节点的父亲节点。如下图所示：
更理想的情况是将层数压为一层，如下图所示：

// 查找过程, 查找元素p所对应的集合编号
// O(h)复杂度, h为树的高度
int find(int p){
    assert( p >= 0 && p < count );

    // path compression 1
    while( p != parent[p] ){
        parent[p] = parent[parent[p]];
        p = parent[p];
    }
    return p;

    // path compression 2, 递归		
    // if( p != parent[p] )
    //    parent[p] = find( parent[p] );
    // return parent[p];
}

经过路径压缩后，时间复杂度近乎为O(1)

哈哈coding

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
并查集

并查集文章目录并查集概述基本数据表示Quick FindQuick Union优化基于size的优化基于rank的优化路径压缩概述并查集用来解决连接问题对于一组数据，主要支持两个操作：union(p,q)：将p和q连接起来find(p)：查p具体是在哪个组中以上两个操作用来回到isConnected(p,q)：判断p、q是否相连基本数据表示Quick Find用一个数组表示每个数据的连接关系，其中数组中的每个元素是该数据所属的组。如上图所示，编号为0的元素相连，编号为
复制链接

扫一扫

专栏目录