08 数据结构与算法之并查集（C语言实现）

最新推荐文章于 2024-04-27 09:47:41 发布
最新推荐文章于 2024-04-27 09:47:41 发布
阅读量275 收藏
点赞数
分类专栏： 数据结构与算法 C语言 文章标签： c语言 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_36002055/article/details/124925961
版权

8 森林与并查集

并查集是用来解决联通问题的结构
森林是并查集的别名，他俩指代的是同一种结构

8.1 Introduce

8.1.1 Quick-Find算法

1、基于染色的思想，一开始所有点的颜色不同
2、连接两个点的操作，可以看成将一种颜色的点染成另一种颜色
3、如果两个点颜色一样，证明联通，否则不联通
4、这种方法叫做并查集的:Quick-Find算法】

合并操作流程：

  • 合并操作要遍历所有元素时间复杂度O(n)

1、4与3连通：用3号点颜色标记4号点颜色(也可用4号标记3号，规则自定)用3号点颜色标记4号点颜色(反之亦然，规则自定)

2、将4号点的颜色改为3号点标记，在这里插入图片描述

3、4与8连通：只要和4号点颜色相同的点都要改为8号点的颜色
在这里插入图片描述

4、6与5连通在这里插入图片描述

5、9与4连通
在这里插入图片描述

6、2与1连通
在这里插入图片描述

7、5与0连通
在这里插入图片描述

8、7与2连通
在这里插入图片描述

9、6与1连通
在这里插入图片描述

10、合并结束
在这里插入图片描述

8.1.2 Quick-find算法总结

1、联通判断:o(1)
2、合并操作:o( n)

问题思考:
1、quick-find算法的联通判断非常快，可是合并操作非常慢
2、本质上问题中只是需要知道一个点与哪些点的颜色相同
3、而若干点的颜色可以通过间接指向同一个节点
4、合并操作时，实际上是将一棵树作为另一棵树的子树

8.1.3 Quick-Union算法

找代表元素，只需修改两个集合中的代表元素,即元素的代表元素。若本身元素的代表元素为本身时，只修改本身元素的代表元素的编号。若不同，则继续再查找本身元素的代表元素，重复上述操作，直到本身元素与本身代表元素相同时，才修改所查找到的元素的代表元素。

8.1.4 Quick-Union算法总结

1、联通判断: tree-height树高
2、合并操作: tree-height树高

问题思考:
1、极端情况下会退化成一条链
2、将节点数量多的接到少的树上面，导致了退化
3、将树高深的接到浅的上面，导致了退化

若要改进，是按照节点数量还是按照树的高度为合并参考? -->>节点数少的树作为子树

8.1.5 练习1

在这里插入图片描述

1、quick-find算法最终数组的结果

0123456789
5555556666

2、quick-union算法最终数组的结果

0123456789
1244556697

8.1.6 weighted quick-union算法

weighted quick-union算法是为了避免出现quick-union退化成链表的情况(按秩[节点的权值]优化)

本身元素的代表元素数量和下一个代表元素比较，数量相同，二者均可相互代表。若不等，选择代表元素多的作为代表，替换需要被代表的元素的代表元素，如有多个则选取根节点改为节点数多的那一个

在这里插入图片描述

quick-union算法

0123456789
5133156697

weighted quick-union算法

0123456789
1333339999

8.1.7 练习2

在这里插入图片描述
quick-union算法

0123456789
1244556697

weighted quick-union算法

0123456789
1244556697

8.1.8 weighted quick-union算法总结

在这里插入图片描述

路径压缩：将0号节点挂在3号节点下

8.1.9 并查集相关算法时间复杂度

AlgorithmConstructorUnionFind
Quick-FindNN1
Quick-UnionNTree heightTree height
Weigthted Quick-UnionNlog Nlog N
Weighted Quick-Union With Path CompressionNVery near to 1(amortized)Very near to 1(amortized)

扩展阅读：
1、http://blog.csdn.net/dm_vincent/article/details/7655764
2、http://blog.csdn.net/dm_vincent/article/details/7769159

8.2 并查集代码

结合一道算法题展示代码：朋友圈
题目描述：
​ 所谓一个朋友圈子，不一定其中的人都互相直接认识。

​ 例如：小张的朋友是小李，小李的朋友是小王，那么他们三个人属于一个朋友圈。

​ 现在给出一些人的朋友关系，人按照从 1 到 n 编号在这中间会进行询问某两个人是否属于一个朋友圈，请你编写程序，实现这个过程。

输入
第一行输入两个整数 n,m(1≤n≤10000，3≤m≤100000)，分别代表人数和操作数。

接下来 m 行，每行三个整 a,b,c（a∈[1,2], 1≤b,c≤n）
当 a=1 时，代表新增一条已知信息，b,c 是朋友
当 a=2 时，代表根据以上信息，询问 b,c 是否是朋友
输出
对于每个 a=2 的操作，输出『Yes』或『No』代表询问的两个人是否是朋友关系。

样例输入
6 5
1 1 2
2 1 3
1 2 4
1 4 3
2 1 3
样例输出
No
Yes

8.2.1 Quick_find 724ms

#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));
    u->n = n;
    for (int i = 1; i <= u->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) {//连通a, b
    if (find(u, a) == find(u, b)) return 0;//a,b已经连通
    int color_a = u->color[a];
    for (int i = 1; i <= u->n; i++) {
    		//if (u->color[i] == color_a) {
    		//		 u->color[i] = u->color[b];
    		//}//可根据对偶逻辑改为if (u->color[i] != color_a) continue;
        if (u->color[i] - color_a) continue;
        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;
}

8.2.2 Quick_union 1892ms

1．基于找代表元素思想完成的
2.问题思考:
1.极端情况下会退化成—条链
2.将节点数量多的接到少的树下面，导致了退化
3.将树高深的接到浅的下面，导致了退化

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

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));
    u->n = n;
    for (int i = 1; i <= u->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);//a,b的代表元素
    if (fa == fb) return 0;//代表元素相同则不需要合并操作
    u->father[fa] = fb;//可将a的代表元素改为b的代表元素fb
    return 1;
}
void clear(UnionSet *u) {
    if (u == NULL) return ;
    free(u->father);
    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;
}

8.2.3 Weigth quick_union按秩优化 164ms

相关优化方式
1、weighted quick-union算法
2、按秩(可理解为节点的权重)优化
3、路径压缩

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

#define swap(a, b) {\
    a ^= b; b ^= a; a ^=b;\
}

typedef struct UnionSet {
    int *father, *size;//size为代表元素的这个数的总的节点数
    int n;
} UnionSet;

UnionSet *init(int n) {
    UnionSet *u = (UnionSet *)malloc(sizeof(UnionSet));
    u->father = (int *)malloc(sizeof(int) * (n + 1));
    u->size= (int *)malloc(sizeof(int) * (n + 1));
    u->n = n;
    for (int i = 1; i <= u->n; i++) {
        u->father[i] = i;
        u->size[i] = 1;//每个节点个数初始化为1
    }
    return u;
} 

int find (UnionSet *u, int x) {
    if (u->father[x] == x) return x;
    return find(u, u->father[x]);
  	//return u->father[x] = find(u, u->father[x]); //路径压缩优化,例如将x->a, a->b, b->c压缩为x->c,a->c,b->c。
}
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);//fa节点的代表元素(构成树的节点)个数少于fb节点的代表元素个数。假定fa一直记录节点个数多的那个值，fb始终记录节点个数少的值
    u->father[fb] = fa;//fb(节点个数少的子树)作为合并后的子树
    u->size[fa] += u->size[fb];//更新fa元素的节点所在数的节点个数
    return 1;
}
void clear(UnionSet *u) {
    if (u == NULL) return ;
    free(u->father);
    free(u->size);
    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;
}

8.2.4 quick_union 只加路径压缩 172ms

/*************************************************************************
	> File Name: 19.weigth_union.c_
	> Author: 
	> Mail: 
	> Created Time: Fri 11 Jun 2021 08:38:48 PM CST
 ************************************************************************/
#include <stdio.h>
#include <stdlib.h>

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));
    u->n = n;
    for (int i = 1; i <= u->n; i++) {
        u->father[i] = i;
    }
    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;//代表元素相同则不需要合并
    u->father[fb] = fa;//fb(节点个数少的子树)作为合并后的子树
    return 1;
}
void clear(UnionSet *u) {
    if (u == NULL) return ;
    free(u->father);
    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;
}

参考链接：https://www.bilibili.com/video/BV19S4y157N3?p=19

Mr_GouDan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
所有基础数据结构和算法的纯C语言实现.zip
04-27
，如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等，献丑了
并查集（详细解释+完整C语言代码）
热门推荐
weixin_54186646的博客
04-28 1万+
并查集的详细逻辑梳理与完整代码实现，包括查询、合并、路径压缩等操作。
C语言经典算法之并查集
weixin_56154577的博客
01-26 885
并查集（Disjoint Set Union，简称并查集，也叫不相交集合）是一种用来管理分组的数据结构。它主要支持两种操作：查找（Find）和合并（Union）。并查集通常用于处理元素的分组问题，比如连通性的问题，网络连接状态的问题等。
使用C语言实现并查集
Keep_Trying_Go的博客
08-19 713
使用C语言实现并查集
并查集入门讲解（C语言）
weixin_63617665的博客
03-20 1867
众所周知，并查集在数据结构部分有着不可忽视的作用，今天就由小编带着大家来学习一下并查集吧。 首先，我们需要知道并查集的作用：并查集是若干个不相交集合,能够实现较快的合并和判断元素所在集合的操作。同时也有不少考题是来考察并查集的，这就需要我们长时间的练习与思考。 并查集被很多学者认为是最简洁而优雅的数据结构之一，主要用于解决一些元素分组的问题。它管理一系列不相交的集合，并支持两种操作： 合并（Union）：把两个不相交的集合合并为一个集...
并查集(概念+代码实现)详解———C语言
ThePythonFucker的博客
02-23 1788
目录 定义 存储结构 例子 代码实现 并查集结构定义 并查集初始化操作(S即为并查集) Find操作(函数在并查集中进行查找x元素，并返回包含x元素的树的根节点) Union操作（函数求两个并不相交的子集合的并集） 定义 并查集是一种简单的集合表示，支持以下三种操作： 1）Initial(S):将集合S中的每个元素都初始化为只有一个单元素的子集合。 2）Union(S,Root1,Roo2):把集合S中的子集合Root2并入子集合Root1。（要求Root1和Root2互不相交，否.
数据结构之并查集（模板）
08-17
并查集实现，带路径压缩和template，高效查找神器！注：库里面如果没有unordered_map，可以换成hash_map或者map
所有基础数据结构和算法的纯C语言实现
11-03
所有基础数据结构和算法的纯C语言实现，如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等，献丑了
并查集算法
08-01
深入理解并查集算法，细致讲解，专业老师，一步到位 。
严蔚敏《数据结构(c语言版)习题集》(带完整答案)
04-28
本文是对严蔚敏《数据结构(c 语言版)习题集》一书 和严蔚敏《数据结构(c 语言版)习题集中所有算法
并查集的实现
09-16
递归路劲压缩，并查集按秩归并，找到根节点，非递归路劲压缩
并查集C/C++代码实现
09-11
按照算法导论的描述的并查集，集合并操作O（1），查找操作O(lgn)的复杂度。
C语言建立并查集
墨城烟柳ベ旧人殇的博客
06-22 507
本文主要通过C语言建立并查集、并进行优化。
洛谷1111修复公路
weixin_30544657的博客
11-09 167
题目背景 A地区在地震过后，连接所有村庄的公路都造成了损坏而无法通车。政府派人修复这些公路。 题目描述 给出A地区的村庄数N，和公路数M，公路是双向的。并告诉你每条公路的连着哪两个村庄，并告诉你什么时候能修完这条公路。问最早什么时候任意两个村庄能够通车，即最早什么时候任意两条村庄都存在至少一条修复完成的道路（可以由多条公路连成一条道路） 输入输出格式 输入格式： 第1行两个正整数...
再谈C语言——理解指针（四）
Lucas_Micheal的博客
04-24 1063
assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏。这个宏常常被称为“断⾔”。上⾯代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL。如果确实不等于 NULL ，程序 继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣ 任何作⽤，程序继续运⾏。
Atcoder Beginner Contest 350 C - Sort
最新发布
2301_76723927的博客
04-27 1035
给定一个排列 A=(A1, ..., AN) ，其中包含数字 1 到 N 的一个排列。通过执行 0 到 N-1 次操作，将排列 A 转换为 (1, 2, ..., N)。每次操作如下：选择任意一对整数 (i, j)，其中 1≤i<j≤N，在排列 A 中交换第 i 个位置和第 j 个位置上的元素。在给定的约束条件下，可以证明始终可以将排列 A 转换为 (1, 2, ..., N)。通过从开头迭代元素并将每个元素与正确位置上的元素交换，最多可以通过 (N-1) 次操作实现目标。
【C语言】typedef
qq_45951891的博客
04-25 208
2)在连续定义几个变量的时候，typedef能够保证定义的所有变量的均为同一类型，而#define却无法保证。1)可以使用其他类型说明符对宏类型名进行扩展，但对typedef所定义的类型名却不能这样做。为一个数据类型起一个新的别名。
【经典算法】LeetCode104二叉树的最大深度(Java/C/Python3实现含注释说明,Easy)
2401_84427485的博客
04-25 890
方式优点缺点时间复杂度空间复杂度递归深度优先搜索代码直观，易于理解递归可能导致栈溢出，对于深层树效率较低O(n)O(h)非递归深度优先搜索避免递归栈溢出，适用于深层树需要手动维护栈，代码相对复杂O(n)O(h)广度优先搜索层次遍历，易于实现需要额外的队列空间，空间复杂度较高O(n)O(n)
c++图论基础(2)
2301_79249663的博客
04-26 551
当数据中0较多，比较占用内存空间，可以考虑用邻接表。每一行第一列表示的是最外层vector数组的下标。用来计算顶点的入度和出度,入度看行，出度看列。无向图的邻接矩阵是对称的，2是自环。
c语言实现 城市燃气管道铺设的问题 实践用并查集实现Kruskal算法
05-24
下面是C语言实现Kruskal算法的示例代码，其中用到了并查集的数据结构。 ```c #include #include #define MAX_VERTEX_NUM 20 // 定义边的结构体 typedef struct { int u; // 起点 int v; // 终点 int w; // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值