【C++】【并查集】并查集实现、模板；并查集基于size、rank的优化；

最新推荐文章于 2021-08-07 15:22:12 发布
最新推荐文章于 2021-08-07 15:22:12 发布
阅读量468 收藏 1
点赞数 1
分类专栏： 数据结构与算法 c/c++ 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44503157/article/details/118324858
版权

目录

一、引入并查集

○ 解决连接问题（网络中节点的连接问题）（两个社交网络中的人能不能根据好友互相认识）。
○ 数学中的集合类的实现。
○ 并查集的高效是因为只回答了连接问题，没有回答路径问题。

1、连接问题与路径问题：

连接问题要比路径问题回答的问题少，所以更高效。路径问题还是得看图论。

算法的实现：如果额外的回答了别的问题，那么可能存在更加高效的算法，只回答了需要的问题。

2、接口

并查集需要支持的接口：一组数据需要支持：//优化到最后，其时间复杂度近乎是O(1);

Union(p,q)

find (p )

isconnected(p,q)

二、基础并查集

1、 Quickfind模式：

用ID 数组来表示两个节点的连接性。

Find 、isconnected只需要O(1) ；Union需要O(n)，需要优化。

○ 初始化的时候，自己和自己是连通的。
○ 并的时候，需要O(n)让两个相连的连在一起。
○ 查的时候，只需要查ID数组中数一样，就是连接的。
在这里插入图片描述

1.1、实现

// Union-Find
class UnionFind {

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

2、Quickunion模式：

每个元素有一个指向父亲节点的指针。可以用数组来表示，数组中存的是指向父节点的指针。

○ 初始化的时候，指针指向自己，表示为自己为自己的根。
○ 并的时候，只需要让其根连到另一个的根上。
○ 查的时候，只需要查两个节点在不在一个根上。
在这里插入图片描述

2.1、实现

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

3、Quickunion模式优化：

以下优化都是为了降低树高，使得降低操作时间复杂度。

3.1、 Quickunion优化size：

加一个size数组，表示当前根节点所在树的节点个数。

union 的时候让小size的并到大size的根中。降低树的高度。这样已经比上面两种快了一个数量级了。

union 的时候更新 size。
在这里插入图片描述

优化size实现

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

3.2、 Quickunion优化rank：

size 优化存在的问题：因为size记录的不是树高，会造成矮胖树并到高瘦树中，造成树依然很高。

将size数组优化为rank数组，表示当前根节点的数高。

○ 并的时候，让矮的树并到高的树中；如果两个树一样高，将一个并到另一个，作为根的高度++;
○ 同样为了降低树的高度。但是对于size优化，效果不明显，因为极端的情况很少，反而因为判断增加，造成运算消耗。但是总体还是比size理想。

在这里插入图片描述

优化rank实现

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的值
        }
    }
};

3.3、路径压缩1 优化find

○ 优化find：让其向上找根的时候，如果父节点不是根，就让父节点指向父节点的父节点。

在这里插入图片描述

路径压缩1 实现

    class UnionFind{

    private:
        // rank[i]表示以i为根的集合所表示的树的层数
        // 在后续的代码中, 我们并不会维护rank的语意, 也就是rank的值在路径压缩的过程中, 有可能不在是树的层数值
        // 这也是我们的rank不叫height或者depth的原因, 他只是作为比较的一个标准
        // 关于这个问题，可以参考问答区：http://coding.imooc.com/learn/questiondetail/7287.html
        int* rank;
        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 );

            // 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];
        }

        // 查看元素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的值
            }
        }
    };

3.4、路径压缩2 优化find

理论上最优，但是因为递归的消耗，使得效果可能没有上面的优化好。

优化find：让其向上找根的时候，递归的将其父节点返回，赋值给当前节点。使树的高度为2.
结束条件为，当前节点的父节点是自己，因为根是指向自己的。

在这里插入图片描述

路径压缩2 实现

class UnionFind{

public: // 后续, 我们要在外部操控并查集的数据, 在这里使用public
    int* parent; // parent[i]表示第i个元素所指向的父节点

private:
    // rank[i]表示以i为根的集合所表示的树的层数
    // 在后续的代码中, 我们并不会维护rank的语意, 也就是rank的值在路径压缩的过程中, 有可能不在是树的层数值
    // 这也是我们的rank不叫height或者depth的原因, 他只是作为比较的一个标准
    // 关于这个问题，可以参考问答区：http://coding.imooc.com/learn/questiondetail/7287.html
    int* rank;
    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 );

        // path compression 2, 递归算法
        if( p != parent[p] )
            parent[p] = find( parent[p] );
        return parent[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的值
        }
    }

    // 打印输出并查集中的parent数据
    void show(){
        for( int i = 0 ; i < count ; i ++ )
            cout << parent[i] << " ";
        cout <<endl;
    }
};

参考

bobo老师github

怎么这么帅啊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法C++之并查集 基于rank的优化
恰同学少年的博客
11-19 558
上一篇博客中，选择根节点数目少的节点指向根节点数目多的节点，这种策略一般是没有问题的，但是如果是下图的情况，要合并4和2 根据根节点数目少的指向根节点数目多的，4的根节点数目为3，2的根节点数目为6，那么需要将4的根节点8指向2的根节点7，但是这样树的高度变为4 而如果将2的根节点7指向4的根节点8，那么这样树的高度变为3，因此需要根据树的高度来判断谁指向谁 根据树的高度判断指向，称为基于r...
C++ 并查集算法
struct_GS的博客
08-13 3351
并查集简介 并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间（1～3秒）内计算出试题需要的结果，只能用并查集来描述。 ...
数据结构与算法分析（Java语言描述）（23）—— 并查集基于 size 和 rank 的优化
HeatDeath的博客
11-16 715
基于 size 的优化package com.dataStructure.union_find;public class UnionFind3 { private int[] parent; // parent[i]表示第一个元素所指向的父节点 private int[] size; // sz[i]表示以i为根的集合中元素个数 private int count;
集合——并查集的C++实现及优化
yuanmartin的博客
09-09 9109
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 并查集的C++实现及优化前言一、什么是并查集（Disjoint-set）三、C++实现一方法一：方法二：五、C++实现二（优化版）总结 前言 提并查集（Disjoint-set） 的代码非常简洁，但是功能却很强大。 关于并查集，这里有一篇文章超有爱的并查集~，讲得非常好，但是只使用了并查集两个主要优化中的"路径压缩"优化，并且我觉得很多情况下采用递归的写法要比采用循环的写法要易懂很多。本文将使用C++实现并查集并使用“按秩合并”和”路径压
基于Rank的并查集优化
扬俊的小屋
12-27 3249
在上一小节中，我们讨论了基于Size的并查集优化方法，即在合并两个集合时，通过判断两个集合元素的数量大小来决定把哪一个集合并入另一个集合当中，从而减少了因为合并集合使得合并后树的层数增多的情况，因此执行find操作所需的步骤数量也大大减少了。但是，没有绝对完美的优化方法，这种基于Size的合并策略在有的时候却并不能很好的解决合并时发生层数增多的问题，例如下面这种情况： 我们可以看
200.岛屿数量
s11235218的博客
08-07 231
200.岛屿数量 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1： 输入：grid = [ [“1”,“1”,“1”,“1”,“0”], [“1”,“1”,“0”,“1”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0”,“0”,“0”,“0”] ] 输出：1 示例 2： 输入：grid = [ [“1
c++并查集优化（基于size和rank）
08-25
在 C++ 中，我们可以使用基于 size 和 rank 的优化方法来实现并查集算法。 基于 size 的优化是指在集合合并时，让数据少的集合指向数据多的集合。这种方法可以减少树的高度，提高查找的效率。在代码实现中，我们...
C++实现并查集
08-18
C++ 实现并查集 C++ 实现并查集是一种常用的数据结构，它可以高效地管理和操作集合。并查集（Union-Find）是一种数据结构，它可以用来解决连接问题和路径压缩问题。 UnionFind 类的实现 在给定的代码中，我们...
C++利用map实现并查集
12-17
在C++中，我们可以利用`std::map`来实现并查集。`fathermap`是一个`, data>`类型的映射，用于存储每个元素的父结点。初始时，每个元素都是自己的父结点，即每个元素都是一个独立的集合。在`finddeputy`函数中，我们...
并查集（C++实现）
clearlove_black的博客
06-03 996
直接上代码，操作、解释都在里面’#include &lt;iostream&gt; using namespace std; const int MAX_N = 200001; int par[MAX_N]; int rank_[MAX_N]; void init(int n){ // 初始化 n 个元素 for(int i = 0; i &lt; n; ++i){ ...
并查集模板
06-24
并查集模板并查集模板并查集模板并查集模板并查集模板并查集模板
并查集C/C++代码实现
09-11
按照算法导论的描述的并查集，集合并操作O（1），查找操作O(lgn)的复杂度。
并查集及优化(C++)
Rocky0429
03-14 1513
#include <iostream> #include <algorithm> #include <string> #include <cassert> using namespace std; /* //查找快，但是合并差 class UnionFind1{ private: int *id; int Count;public: UnionFind1(int n){
C++-并查集模板
qq_41093189的博客
01-28 911
并查集的模板 find()函数的定义 连接的操作 需要注意的是初始化和p[y]=x的顺序不能颠倒!#include #include using namespace std; const int maxn=1000+10; int a[maxn]; //测试数组 int p[maxn]; //使用时要初始化 //find模板 int find(int x){ return x==p[x]?
C++ - 并查集模板
zhanghengrui的博客
08-30 198
Github 洛谷 HOJ #include <cstddef> #include <stdexcept> #include <vector> template<bool index_begin_from_zero = false> class Union_Find { private: std::vector<size_t> par...
并查集----------模板（C++实现）
weixin_43398169的博客
04-17 185
#include<iostream> #include<windows.h> #include<cassert> //并查集 (连接问题,集合类的问题) //union（p，q） find（p） isconnected using namespace std; class UnionFind1 { private: int *id; int co...
并查集
forever_dreams的博客
07-31 164
知识点系列之---并查集（主要是介绍三种写法）
并查集的C++实现及优化
IT小白的博客
10-30 364
前言 并查集（Disjoint-set） 的代码非常简洁，但是功能却很强大。 关于并查集，这里有一篇文章超有爱的并查集~，讲得非常好，但是只使用了并查集两个主要优化中的"路径压缩"优化，并且我觉得很多情况下采用递归的写法要比采用循环的写法要易懂很多。本文将使用C++实现并查集并使用“按秩合并”和”路径压缩“优化并查集。我们先大概了解什么是并查集。 什么是并查集（Disjoint-set） 对于一个...
用c++编写并查集的模板
最新发布
05-04
以下是使用 C 编写的并查集模板： ```c #define MAXN 10005 int parent[MAXN]; // 存储每个节点的父节点 int rank[MAXN]; // 存储每个节点的秩 // 初始化并查集 void init(int n){ for(int i=1; i; i++){ ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值