数据结构之并查集

最新推荐文章于 2024-02-03 11:27:56 发布
最新推荐文章于 2024-02-03 11:27:56 发布
阅读量113 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzcppc/article/details/112439964
版权

并查集

更加详细的介绍参见：并查集介绍

基础知识

最基本的并查集定义及操作

class UnionSet{
public:
    UnionSet(int n){
        m_n=n;
        m_count=n;
        father=new int[n];
        for(int i=0;i<n;i++){
            father[i]=i;
        }
    }
    int find(int x){
        return father[x]=(father[x]==x?x:find(father[x]));
    }
    void merge(int x,int y){
        int fx=find(x),fy=find(y);
        if(fx==fy) return;
        father[fx]=fy;
        m_count--;
    }
    int getcount(){
        return m_count;
    }
    ~UnionSet(){
        delete []father;
    }
private:
    int m_n; //并查集的大小
    int m_count;//并查集的联通域数量
    int *father;//父节点
};

Quick-Find算法

#include<stdio.h>
#include<stdlib.h>

typedef struct UnionSet{
    int *color;
    int n;
}UnionSet;

UnionSet *init(int n){
    UnionSet *u=(UnionSet *)malloc(sizeof(UnionSet));
    u->color=(int *)malloc(sizeof(int)*(n+1));//将0号 位置空出来
    u->n=n;
    for(int i=1;i<=n;i++){
        u->color[i]=i;
    }
    return u;
}

//查找操作
int find(UnionSet *u,int x){
    return u->color[x];
}

//合并操作
int merge(UnionSet *u,int a,int b){
    if(find(u,a)==find(u,b)) return 0;
    int color_a=u->color[a];
    for(int i=1;i<=u->n;i++){
        //和a的颜色不同，什么都不做直接coninue结束本次循环进入下一次循环
        if(u->color[i]!=color_a) continue; 
        //把所有和a颜色相同的元素的颜色全部改为b的颜色;
        u->color[i]=u->color[b];
    }
    return 1;
}

void clear(UnionSet *u){
    if(u==NULL) return ;
    free(u->color);
    free(u);
    return;
}

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    UnionSet *u=init(n);
    for(int i=0;i<m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        switch(a){
            case 1:merge(u,b,c);break;
            case 2:
                printf("%s\n",find(u,b)==find(u,c)?"Yes":"No");
                break;
        }
    }
    clear(u);
    return 0;
}

Quick-Union算法

typedef struct UnionSet{
    int *father;
    int n;
}UnionSet;

UnionSet *init(int n){
    UnionSet *u=(UnionSet *)malloc(sizeof(UnionSet));
    u->father=(int *)malloc(sizeof(int)*(n+1));//将0好位置空出来
    u->n=n;
    for(int i=1;i<=n;i++){
        u->father[i]=i;
    }
    return u;
}

//查找操作,递归的找寻公共父节点
int find(UnionSet *u,int x){
    if (u->father[x]==x) return x;
    return find(u,u->father[x]);
}

//合并操作
int merge(UnionSet *u,int a,int b){
    int fa=find(u,a),fb=find(u,b);
    if(fa==fb) return 0;
    u->father[fa]=fb;
    return 1;
}

void clear(UnionSet *u){
    if(u==NULL) return ;
    free(u->father);
    free(u);
    return;
}
Weighted-Quick-Union

把节点数量少的接到节点数量多的根节点上。

typedef struct UnionSet{
    int *father,*size;
    int n;
}UnionSet;

UnionSet *init(int n){
    UnionSet *u=(UnionSet *)malloc(sizeof(UnionSet));
    u->father=(int *)malloc(sizeof(int)*(n+1));//将0号位置空出来
    u->size=(int *)malloc(sizeof(int)*(n+1));
    u->n=n;
    for(int i=1;i<=n;i++){
        u->father[i]=i;
        u->size[i]=1;
    }
    return u;
}

//查找操作
int find(UnionSet *u,int x){
    if (u->father[x]==x) return x;
    return find(u,u->father[x]);
}

//合并操作
int merge(UnionSet *u,int a,int b){
    int fa=find(u,a),fb=find(u,b);
    if(fa==fb) return 0;
    //fa记录结点数量最多的位置
    if(u->size[fa]<u->size[fb]) swap(fa,fb);
    u->father[fb]=fa;
    u->size[fa]+=u->size[fb];
    return 1;
}

void clear(UnionSet *u){
    if(u==NULL) return ;
    free(u->father);
    free(u->size);
    free(u);
    return;
}
Weighted-Quick-Union with Compression
typedef struct UnionSet{
    int *father,*size;
    int n;
}UnionSet;

UnionSet *init(int n){
    UnionSet *u=(UnionSet *)malloc(sizeof(UnionSet));
    u->father=(int *)malloc(sizeof(int)*(n+1));//将0好位置空出来
    u->size=(int *)malloc(sizeof(int)*(n+1));
    u->n=n;
    for(int i=1;i<=n;i++){
        u->father[i]=i;
        u->size[i]=1;
    }
    return u;
}

//查找操作
int find(UnionSet *u,int x){
    if (u->father[x]==x) return x;
    //路径压缩更改此位置，每次都是最顶层的根节点
    return u->father[x]=find(u,u->father[x]);
}

//合并操作
int merge(UnionSet *u,int a,int b){
    int fa=find(u,a),fb=find(u,b);
    if(fa==fb) return 0;
    if(u->size[fa]<u->size[fb]) swap(fa,fb);
    u->father[fb]=fa;
    u->size[fa]+=u->size[fb];
    return 1;
}

void clear(UnionSet *u){
    if(u==NULL) return ;
    free(u->father);
    free(u->size);
    free(u);
    return;
}

练习题

128 最长连续序列

leetcode 128 hard
在这里插入图片描述

对于unordered_map，底层实现为哈希表，其中：
使用count，返回的是被查找元素的个数。如果有，返回1；否则，返回0。注意，map中不存在相同元素，所以返回值只能是1或0。

使用find，返回的是被查找元素的位置，没有则返回map.end()。

class Solution {
public:
    unordered_map<int,int>uf,cnt;
    //并查集的find操作，其中采用了压缩路径
    int find(int x){
        return uf[x]=(uf[x]==x?x:find(uf[x]));
    }
    //并查集的union操作，其中weighted-union;
    int merge(int x,int y){
        int fx=find(x),fy=find(y);
        if(fx==fy) return cnt[fx];
        //把较小数量的树接在较大数量的树下
        if(cnt[fx]<cnt[fy]) swap(cnt[fx],cnt[fy]);
        uf[fy]=fx;
        cnt[fx]+=cnt[fy];
        return cnt[fx];
    }

    int longestConsecutive(vector<int>& nums) {
        if(nums.size()==0) return 0;
        int res=1;
        //初始化并查集的father和size;
        for(int i:nums){
            uf[i]=i;
            cnt[i]=1;
        }
        for(int i:nums){
        //如果i+1存在，合并，并返回较大的子树数量
            if(uf.count(i+1)){
                res=max(res,merge(i,i+1));
            }
        }
        return res;
    }
};

130 被围绕的区域

leetcode130
在这里插入图片描述

class UnionSet{
public:
    UnionSet(int n){
        this->m_n=n;
        this->father=new int[n];
        for(int i=0;i<n;i++){
            father[i]=i;
        }
    }
    int find(int x){
        //采用路径压缩可以减少时间
        return father[x]=(father[x]==x?x:find(father[x]));
        //if(father[x]==x) return x;
        //return find(father[x]);
    }
    void  merge(int x,int y){
        int fx=find(x),fy=find(y);
        if(fx==fy) return;
        father[fx]=fy;
    }
    bool isconnect(int x,int y){
        return find(x)==find(y);
    }
    ~UnionSet(){
        delete[]father;
    }
private:
    int *father;
    int m_n;
};

class Solution {
public:
    int node(int x,int y,int j){
        return x*j+y;
    }
    int dir[2][2]={0,1,1,0};
    void solve(vector<vector<char>>& board) {
        if(board.size()==0||board[0].size()==0) return ;
        //初始化并查集的大小为N+1;下标元素为0-N;
        UnionSet u=UnionSet(board.size()*board[0].size()+1);
        //设置虚拟父节点为N;将边界上为O的点与虚拟父节点联通
        int dummpy_fa=board.size()*board[0].size();
        for(int i=0;i<board.size();i++){
            for(int j=0;j<board[0].size();j++){
                if(board[i][j]!='O') continue;
                bool edge=i==0||i==board.size()-1||j==0||j==board[0].size()-1;
                for(int k=0;k<2;k++){
                    int xx=i+dir[k][0];
                    int yy=j+dir[k][1];
                    if(xx<board.size()&&yy<board[0].size()&&board[xx][yy]=='O'){
                        u.merge(node(xx,yy,board[0].size()),node(i,j,board[0].size()));
                    }
                }
                if(!edge) continue;
                u.merge(node(i,j,board[0].size()),dummpy_fa);
            }
        }
        for(int i=0;i<board.size();i++){
            for(int j=0;j<board[0].size();j++){
                if(board[i][j]!='O') continue;
                if(!u.isconnect(dummpy_fa,node(i,j,board[0].size()))){
                    board[i][j]='X';
                }
            }
        }
    }
};

200 岛屿数量在这里插入图片描述

class UnionSet{
public:
    UnionSet(int n){
        m_n=n;
        m_count=n;
        father=new int[n];
        for(int i=0;i<n;i++){
            father[i]=i;
        }
    }
    int find(int x){
        return father[x]=(father[x]==x?x:find(father[x]));
    }
    void merge(int x,int y){
        int fx=find(x),fy=find(y);
        if(fx==fy) return;
        father[fx]=fy;
        m_count--;
    }
    int getcout(){
        return m_count;
    }
    ~UnionSet(){
        delete []father;
    }
private:
    int m_n;
    int m_count;
    int *father;
};

class Solution {
public:
    int node(int x,int y,int cols){
        return x*cols+y;
    }
    int dir[2][2]={0,1,1,0};
    int numIslands(vector<vector<char>>& grid) {
        if(grid.size()==0||grid[0].size()==0) return 0 ;
        int rows=grid.size(),cols=grid[0].size();
        int zero_num=0;
        UnionSet u=UnionSet(rows*cols);
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                if(grid[i][j]=='0'){
                    zero_num++;
                }else{
                    for(int k=0;k<2;k++){
                        int xx=i+dir[k][0];
                        int yy=j+dir[k][1];
                        if(xx<rows&&yy<cols&&grid[xx][yy]=='1')
                            u.merge(node(i,j,cols),node(xx,yy,cols));
                    }
                }
            }
        }
        return u.getcout()-zero_num;
    }
};
ZZcppc
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 之 并查集
小邓笔记
11-24 4312
并查集是一种树型的数据结构，其保持着用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。 有一个联合-查找算法（union-find algorithm）定义了两个操作用于此数据结构： Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。Union：将两个子集合并成同一个集合。 下面代码实现一些并查集中的一些基本操作： 一、并查集的
数据结构之并查集：按秩合并与路径压缩优化
Sakura_lht
11-15 2114
并查集 1.并查集描述 一些有NNN个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。 为了快速解决这些问题，便有了并查集的概念。 并查集维护了一个不相交的动态集的集合S1,S2,⋯ ,Sn{S_1,S_2,\cdots,S_n}S1​,S2​,⋯,Sn​，每个集合将有一个"首领"来标识该集...
【算法与数据结构】—— 并查集
热门推荐
酱懵静的博客
03-26 14万+
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。 数组 pre[ ] 记录了每个点的前驱节点是谁，函数 find(x) 用于查找指定节点 x 属于哪个集合，函数 join(x,y) 用于合并两个节点 x 和 y 。
数据结构与算法之并查集
白大锅的博客，毕设WangLoveBai_999
11-25 5412
并查集 并查集是一种树型的数据结构 ，并查集可以高效地进行如下操作： 查询元素 p和元素q是否属于同一组 合并元素 p和元素q所在的组 1.1.并查集结构 并查集也是一种树型结构，但这棵树跟我们之前讲的二叉树、红黑树、B树等都不一样，这种树的要求比较简单： 1.每个元素都唯一的对应一个结点； 2.每一组数据中的多个元素都在同一颗树中； 3.一个组中的数据对应的树和另外一个组中的数据对应的树之间没有任何联系； 4.元素在树中并没有子父级关系的硬性要求； 1.2 并查集API设计 类名 UF
【数据结构进阶】并查集
孙宇航的博客
01-06 2721
并查集 正如它的名字一样，并查集（Union-Find）就是用来对集合进行 合并（Union） 与 查询（Find） 操作的一种数据结构。 合并 就是将两个不相交的集合合并成一个集合。 查询 就是查询两个元素是否属于同一集合。 并查集的原理 并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。 组成 并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。
数据结构——并查集
weixin_38384296的博客
05-16 1652
并查集是一种数据结构，是树的一种应用，用于处理一些不交集（一系列没有重复元素的集合）的合并以及查询问题。并查集支持如下操作： 查询：查询某个元素属于哪个集合，通常是返回集合内的一个“代表元素”。这个操作一般是为了判断两个元素是否在同一个集合之中。 合并：将两个集合合并为一个。 添加：添加一个新集合，其中有一个新元素。不如查询和合并操作重要。 我们来看下面一个比较有趣的并查集应用的例子： 话说江湖上散落着各式各样的大侠，有上千个之多。他们没有什么正当职业，整天背着剑在外面走来走去，碰到和自己不是一路人的
【数据结构】并查集(路径压缩)
The porters of knowledge
02-03 1542
并查集
【数据结构与算法】并查集
白晨的博客
01-31 3148
大家好，我是白晨，这次为大家带来的数据结构是并查集，这是一种能够快速合并两个集合以及快速查询两个元素是否在一个集合中，时间复杂度在大量查询的情况下可以达到O(1)的数据结构，由于实现思路简单，代码短，性质好，经常会在算法题中用到。同时，并查集也在与图相关的算法中出现过很多次，例如，最小生成树Kruskal算法就使用了并查集。并查集 （英文：Disjoint-set data structure，直译为不交集数据结构）是一种数据结构 ，用于。
【数据结构与算法】——并查集
雪月清的博客
04-14 3113
并查集：一种树型数据结构，用于解决一些不相交集合的合并及查询问题。例如：有n个村庄，查询2个村庄之间是否有连接的路，连接2个村庄 两大核心： 查找 (Find) : 查找元素所在的集合 合并 (Union) : 将两个元素所在集合合并为一个集合 并查集有两种常见的实现思路：快查、快并
c语言数据结构之并查集 总结
12-31
并查集(Union-Find Set)： 一种用于管理分组的数据结构。它具备两个操作：(1)查询元素a和元素b是否为同一组 (2) 将元素a和b合并为同一组。 注意：并查集不能将在同一组的元素拆分为两组。 并查集的实现： 用树来实现...
数据结构之并查集（模板）
08-17
并查集实现，带路径压缩和template，高效查找神器！注：库里面如果没有unordered_map，可以换成hash_map或者map
ACM-数据结构-并查集学习
02-20
ACM-数据结构-并查集学习
数据结构并查集 查询 快速
05-29
数据结构中的并查集（Disjoint Set）是一种用于处理元素集合的分割问题的数据结构，它主要支持两种操作：合并（union）与查找（find）。在实际应用中，尤其是在算法竞赛（ACM）和图论中，它被广泛用于解决快速查询和...
Java高阶数据结构-并查集.docx
最新发布
07-11
并查集（Disjoint Set Union，DSU）是一种用来管理和合并不相交集合的数据结构，通常用于解决动态连通性问题。它支持两种主要操作：查找（Find）和合并（Union）。
算法与数据结构：并查集
04-23
并查集是一种用于处理不相交集合操作的数据结构，它主要包含两个基本操作：查找（Find）和合并（Union）。在并查集中，通常用森林的结构来表示各个集合，每棵树代表一个集合，树的根节点代表集合的标识。 **查找...
并查集基础(C++版).pptx
01-10
并查集是一种高效的数据结构，主要用于处理集合的合并与查询问题。在C++中，它通常用数组和一些辅助函数来实现。并查集的核心思想是通过树状结构表示不相交集合，并通过查找和合并操作来维护这些集合。 1. **基本...
Java实现并查集
08-18
Java实现并查集是指使用Java语言实现的并查集数据结构。并查集是一种树形结构，可以高效地解决元素之间的连接和分离问题。以下是Java实现并查集的详细知识点： 一、并查集的定义 并查集是一种树形结构，每个元素都...
Leetcode 并查集详解
03-08
并查集（Disjoint Set）是一种用于处理集合合并和查询连通性的数据结构。它主要支持以下两种操作： MakeSet(x): 创建一个新的集合，其中包含元素x，并将其作为单独的集合。 Find(x): 查找元素x所属的集合的代表元素...
并查集与高级数据结构简介
在本章“高级数据结构(上)”中，主要介绍了四个关键概念：并查集、二叉树、线段树和树状数组。这些数据结构在解决特定类型的算法问题时显得尤为重要。 首先，**并查集(DisjointSet)**是一种高效处理不相交集合合并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值