并查集C++实现及优化（以朋友圈子为例）

已于 2022-05-10 11:47:04 修改
阅读量1.2k 收藏 5
点赞数 3
分类专栏： 我的数据结构学习 文章标签： mysql 数据结构 c++ 图论
于 2022-05-04 23:32:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wang98423/article/details/124579085
版权

“并查集"去年加入了考纲，正好之前在准备比赛时也看了一下这个算法，然后也学习王道的数据结构，所以总结一下。

文章目录

在接触这个算法之前，怎么根据关系划分圈子一直困扰着我，之前想实现一下QQ空间的效果，而这个算法提供拓宽了我的思路（希望各位大佬更大地帮我拓宽思路）。
OK，先从概念开始。

并查集基本概念（Union-Find-Disjoint）

并查集，旨在将集合中有关联的元素，连接到一块形成一棵树，当然，由于联系有很多很多可能，所以最终可能存在着多棵互不交集的树。

“查”：指的是查找某个结点的根节点。

“并”：指的是合并两个不一样的根节点。

“集”：指的是集合。

举个不是很恰当的小例子：朋友关联圈子

有一个人与我加好友，这就与我构成一个联系，

而另外一个人与我加好友，也与我构成了一个联系，

与我有联系的朋友与我相联，这样我就有了一个朋友关联圈子。

当然，我的朋友可能与别人也有联系（或是有一些跟我和我的朋友们毫无关系的人。）

而并查集能实现的是将它们归类，如下图，归成了两部分，在这里插入图片描述

上图是Find没经过优化的。

下图是上图左边那颗树优化后的结果（一步到位找到我）。
在这里插入图片描述

那么应该怎么存储合适？双亲表示法真是个很棒的思路。

存储结构

使用双亲表示法来存储，也就是节点内存双亲。

需要两个结构体实现，一个是定义类似数组的结构，用于存储节点, 一个是定义每个节点的结构。

//节点结构
typedef struct PTNode{
	int data;
	int parent;
}PTNode;
//顺序表
typedef struct PTree{
	struct PTNode  notes[MAXSIZE];
	int n;
}PTree;

简单模拟操作，我们可以直接用数组代替就行，因为数组本质上就是这样一种结构（顺序表+存数据的节点）

int UFset[MAXSIZE]; 
// 如果存储的值为 -1表示该节点为根节点。（有些人是初始化为下标，都行）
// 如果存储的值为其他正数，表示该节点的父亲节点的下标为该数字

雏形

//初始化
bool Init(int s[]){
	for(int i=0;i<MAXSIZE;i++){
		s[i] = -1; //有些是初始化为下标，都行（即s[i] = i）
	}
	return true;
}
//查，查根节点
int find(int s[],int i){
	//根节点的parent被初始化为-1,所以可以以此为依据查找根节点
    while(s[i]>0){
		i = s[i];	
	}
	return i;
}
//并，合并不同根节点
bool Union(int s[],int root1,int root2){
	//这里显然不能用s[root1] == s[root2]，因为初始时都是-1，除非按照下标初始化 
	if(root1==root2) return false;
	else s[root1] = root2; 
	return true;
}

简单测试

//两个根节点合并
int main(){
	Init(UFset);	
	int root1 = find(UFset,1); 
	int root2 = find(UFset,2);
	printf("%d,%d\n",root1,root2);
	Union(UFset,root1,root2);//root1并到root2
	printf("%d,%d\n",UFset[1],UFset[2]);
	return 0;
}

在这里插入图片描述
优化角度更多了从并操作和查操作角度进行，下面进行Union优化，这个过程也有些小疑惑。

Union优化

思路和疑惑

原Union出现的问题：我们在对于两个根节点并合的时候，可能会导致一棵树的高度不断增高，树高度增高会导致Find查找速度变慢（因为Find会从该节点一直往上找，直到找到根节点）,最坏时间复杂度达O(n^2)

优化方式

将小树主动连到大树上。

怎么判断谁是小树，谁是大树？

利用好根节点（原本存的是-1），负数的绝对值可以表示该树有多少个节点。

优化后的Union：高度不会增长的如同原Union那么快, 树的高度不会超过⌊logn⌋+1,Find最坏时间复杂度O(logn)
在这里插入图片描述
那我一定要大树并小树呢？

在这里插入图片描述
可能会想到，究竟何为大树，何为小树？可以认为是结点数量吗？不用考虑高度？

自然想到，一个很肥，但节点数多，一个很高，但节点数少，二者合并，如下图，看起来好像应该并到小树？
在这里插入图片描述
事实上，上图右边那种树如果按照这个规律构建，即小树根节点都接到了大树根节点上，并不会生成右边这种直挺挺的树，而是左边那种胖胖的树
因此，可以归结成节点数量多为大树，小树根节点该并入大树根节点。

Union优化后代码

bool Union(int s[],int root1,int root2){
	//判断是不是同个根节点，显然不能用s[root1] == s[root2]，因为初始时都是-1，除非按照下标初始化 
	if(root1==root2){
		return false;	
	}else{
		//代表点（顶点）为负数值（其绝对值代表该树节点数量），所以要反着比 
		if(s[root1]>s[root2]){
			s[root2] += s[root1]; //节点数累加
			s[root1] = root2; //小树根root1并到大树根root2 
		}else{ 
			s[root1] += s[root2]; //节点数累加
			s[root2] = root1; //小树根root2并到大树根root1（或两棵同样大小的树）
		}
	}
	return true;
}

Find优化

优化前寻找根节点需要从当前节点不断找向上找双亲节点，将寻找根节点时,路过的节点的双亲节点都设置成根节点（即直连根节点），以后，寻找某个结点的根节点时仅需一步，如下图。
（完成后，寻找3、2节点的根节点，可以一步就找到是1）
在这里插入图片描述

Find优化后代码（递归与非递归实现）

非递归实现

int find(int s[],int i){
	int root = i; 
	//找到根节点（代表节点） 
	while(s[i]>0) root = s[i];
	//将沿途节点的父节点都设置为父节点 (路径压缩)
	while(i!=root){
		int t = s[i]; //将该节点父节点暂存 
		s[i] = root; //将该节点父节点设为root （即直连根节点）
		i = t;		//指向下一个节点（该节点原父节点） 
	} 
	return root; //返回根节点编号 
}

递归实现

int find(int s[],int i){
        if(s[i] < -1){
        	return i;
		}else{
    		//此操作称为路径压缩，目的是将路径的父节点都赋值为根节点
        	s[i] = find(s,s[i]);
        	return s[i];
		}
}

完整代码

（非递归实现）

include<bits/stdc++.h>
#define MAXSIZE 100
using namespace std;
int UFset[MAXSIZE];
/*
typedef struct PTNode{
	int data;
	int parent;
}PTNode;
typedef struct PTree{
	struct PTNode  notes[MAXSIZE];
	int n;
}PTree;
*/
//初始化操作
bool Init(int s[]){
	for(int i=0;i<MAXSIZE;i++){
		s[i] = -1;
	}
	return true;
}

//"查"操作
int find(int s[],int i){
	int root = i; 
	//找到根节点（代表节点） 
	while(s[i]>0) root = s[i];	
	//将沿途节点的父节点都设置为父节点 (路径压缩)
	while(i!=root){
		int t = s[i]; //将该节点父节点暂存 
		s[i] = root; //将该节点父节点设为root 
		i = t;		//指向下一个节点（原父节点） 
	} 
	return root; //返回根节点编号 
}

//"并"操作
bool Union(int s[],int root1,int root2){
	//这里显然不能用s[root1] == s[root2]，因为初始时都是-1，除非按照下标初始化 
	if(root1==root2){
		return false;	
	}else{
		//代表点（顶点）为负数值，所以要反着比 
		if(s[root1]>s[root2]){
			s[root2] += s[root1];
			s[root1] = root2; 
		}else{//1.初始化时 2.以及子节点数更多的在root1时（绝对值） 
			s[root1] += s[root2];
			s[root2] = root1; 
		}
	}
	return true;
}

int main(){
	Init(UFset);	
	int root1 = find(UFset,1);
	int root2 = find(UFset,2);
	printf("%d,%d\n",root1,root2);
	Union(UFset,root1,root2);
	printf("%d,%d\n",UFset[1],UFset[2]);
	return 0;
}

一个小demo——朋友圈归类

实现的效果只是将关系分类。

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 100
//人
class Person{
	public:
		Person(string name);
		string getName();
		int getAge();
		void setName(string name);
		void setAge(int age);
	private:
		string name;
		int age;	
};
Person::Person(string name){
	this->name = name;
}
int Person::getAge(){
	return this->age;
}
string Person::getName(){
	return this->name;
}
//节点结构（每个人的信息） 
typedef struct PTNode{
	Person* someone;
	int index;
	int parent;
}PTNode;
//顺序表(朋友关系链)
typedef struct PTree{
	struct PTNode *notes;
	int n;
}PTree;
//初始化
bool Init(PTree &T,string names[],int num){
	for(int i=0;i<num;i++){
		T.notes[i].someone = new Person(names[i]);
		T.notes[i].index = i;
		T.notes[i].parent = -1;
	}
	return true;
}
//"查"操作
int find(PTree &T,int i){
 	if(T.notes[i].parent <=-1){
    	return i;
	}else{
		 //此操作称为路径压缩，目的是将路径节点的父节点都赋值为祖先节点
    	T.notes[i].parent = find(T,T.notes[i].parent);
    	return T.notes[i].parent;
	}
}
//"并"操作
bool Union(PTree &T,int root1,int root2){
	//判断是否是同个根节点 
	if(root1==root2){
		return false;	
	}else{
		//代表点（顶点）为负数值，所以要反着比 
		if(T.notes[root1].parent> T.notes[root2].parent){
			T.notes[root2].parent += T.notes[root1].parent;
			T.notes[root1].parent = root2; 
		}else{
			T.notes[root1].parent += T.notes[root2].parent;
			T.notes[root2].parent = root1; 
		}
	}
	return true;
}

int main(){
	int r_n,num;
	string p1,p2;
	map<string, int> namemap;
	PTree T;
	cout<<"输入人数:"<<endl;
	cin>>num; 
	string names[MAXSIZE];
	T.notes =(PTNode*) malloc(sizeof(PTNode)*num);
	cout<<"输入他们的名字"<<endl;
	for(int i=0;i<num;i++){
		cin>>names[i];
		namemap[names[i]] = i;
	}
	Init(T,names,num);
	cout<<"关系数量:"<<endl;	
	cin>>r_n;
    //对关系进行归类
	for(int i=0;i<r_n;i++){
		cin>>p1>>p2;
		int root1 = find(T,namemap[p1]);
		int root2 = find(T,namemap[p2]);
		Union(T,root1,root2);
	}
	//打印
	for(int i=0;i<num;i++){
		if(T.notes[i].parent<-1){
			cout<<endl;
			cout<<T.notes[i].someone->getName()<<"(其拥有朋友圈树有节点数="<<abs(T.notes[i].parent)-1<<")"<<endl;
			cout<<"该树有节点:";
		}else{
			cout<<T.notes[i].someone->getName()<<",";
		}
	}
	return 0;
}

结果：
在这里插入图片描述

一些应用展望

并查集完成后，可以给根节点设置一个编号（通过哈希值去算），
数据库根据编号创建一个表（异或是说设一个编号字段），
然后这棵树上的节点可以根据这个编号去，共享操作这个表（或者这个编号字段），
感觉像是个群聊记录存储（或者圈子消息）。
后面有空再尝试看看能不能实现。

总结

  1. 并查集能够实现快速将关联关系并入对应树中。
  2. 每课树都有一个代表性的节点（即根节点）。
  3. Union优化，是将节点数少的树并到节点大的树，这样可以保持树的高度不会太高。
  4. Find优化后，整棵树的节点都会接到这个代表性节点。

不过就仔细想想，好像并查集Find优化后，只需要一步就到达根节点，但是这样也失去了每个节点找到其原父节点这个特性。

由于目前所学尚浅，有更好更简单实现方式，还请各位大佬指教。

Pig_Learning
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++ 并查集练习题朋友圈
wwxy1995的博客
03-28 1475
某学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有着一定相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。请编写程序计算最大朋友圈中有多少人。 输入格式: 输入的第一行包含两个正整数N（≤30000）和M（≤1000），分别代表学校的学生总数和俱乐部的个数。后面的M...
并查集-朋友圈
qq_40861069的博客
12-02 456
某学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有着一定相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。请编写程序计算最大朋友圈中有多少人。 输入格式: 输入的第一行包含两个正整数N（≤30000）和M（≤1000），分别代表学校的学生总数和俱乐部的个数。后面的M行
朋友圈 （并查集）
Coding
03-12 1302
https://pta.patest.cn/pta/test/4175/exam/4/question/62200 5-10 朋友圈   (25分) 某学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有着一定相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。请编写程序...
Leetcode 547. 朋友圈 C++
weixin_43750513的博客
07-17 939
Leetcode 547. 朋友圈 题目 班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。 给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总3数。 测试样例 示例 1: 输入: [[1,1,0], [1,1,0],
c++ 并查集实现 优化
junqing_wu的博客
03-05 492
定义 并查集(Disjoint-Set)是一种可以动态维护若干个不重叠的集合，并支持合并与查询两种操作的一种数据结构 并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。 并查集有两个基本操作： Find: 查找元素所属子集 Union：合并两个子集为一个新的集合 并查集的基本结构 我们可以使用树这种数据结构来表示集合，不...
C++并查集
mystyle_的博客
07-28 2721
转自原文链接 来看一个实例，杭电1232畅通工程 首先在地图上给你若干个城镇，这些城镇都可以看作点，然后告诉你哪些对城镇之间是有道路直接相连的。最后要解决的是整幅图的连通性问题。比如随意给你两个点，让你判断它们是否连通，或者问你整幅图一共有几个连通分支，也就是被分成了几个互相独立的块。像畅通工程这题，问还需要修几条路，实质就是求有几个连通分支。如果是1个连通分支，说明整幅图上的点都连起来了，不用再修路了；如果是2个连通分支，则只要再修1条路，从两个分支中各选一个点，把它们连起来，那么所有的点都是连起来.
并查集模版
12-05
通过本篇文章的学习，我们不仅了解了并查集的基本概念、应用场景以及其实现原理，还详细分析了一个具体的C++代码实现案例。希望读者能够掌握并查集的核心思想，并能够在实际开发中灵活运用这一强大的工具。
用C++做数据分析 - 唐代诗人的朋友圈
海洋饼干叔叔
10-17 2536
通过分析全唐诗中各位诗人之间的“引用”关系，可以描绘出当时诗坛的大致朋友圈图景：谁跟谁熟？谁是圈子里的带头大哥？全唐诗有4万多首，人工一首一首地筛查费时费力，这种重复的统计性质的工作正是计算机最擅长的。
【C C++服务器开发】中间件的含义及常用中间件介绍_c+(1)
最新发布
2401_84263208的博客
04-18 800
DDL 包括 CREATE、DROP、ALTER 等动作。在数据库中使用 CREATE 来创建新表，DROP 来删除表，ALTER 负责数据库对象的修改。例如，创建学生信息表使用以下命令：在实践中，可根据实际情况进行权衡，或者在软件层面提供配置方式，由用户决定如何选择 CAP 策略。CAP 理论可用在不同的层面，可以根据 CAP 原理定制局部的设计策略，例如，在分布式系统中，每个节点自身的数据是能保证 CA 的，但在整体上又要兼顾 AP 或 CP。
ChatGPT写的C++学习路线是怎样的
qq_25854881的博客
02-27 2795
同时，对于C++岗位的薪资也相对较高，根据智联招聘的数据显示，C++岗位的平均薪资为15,000元/月，高级C++工程师的薪资更是超过20,000元/月，因此，C++岗位的就业前景是非常好的。另外，对于一些特定的岗位，如高性能计算、游戏引擎、金融系统等，还需要有相应的专业知识和技能。中国的C++开发岗位要求较为严格，一般要求申请者掌握C++语言的基础知识、熟悉常见的数据结构和算法、掌握Linux操作系统的基础知识、了解网络编程和数据库开发、熟悉常见的框架和库、具备一定的项目经验和技术经验等。
朋友圈问题代码，C语言实现
01-10
某学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有着相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。请编写程序计算最大朋友圈中有多少人。
朋友圈---并查集---C++
Ashen的博客
10-30 610
问题描述 小明所在的学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有 着一定相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干 个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得 出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。请编写程序 计算最大朋友圈中有多少人。 输入 输入包含多组测试数据，每组输入的第一行包含两个正整数N（<=30000） 和M（<...
集合——并查集的C++实现及优化
yuanmartin的博客
09-09 9382
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 并查集的C++实现及优化前言一、什么是并查集（Disjoint-set）三、C++实现一方法一：方法二：五、C++实现二（优化版）总结 前言 提并查集（Disjoint-set） 的代码非常简洁，但是功能却很强大。 关于并查集，这里有一篇文章超有爱的并查集~，讲得非常好，但是只使用了并查集两个主要优化中的"路径压缩"优化，并且我觉得很多情况下采用递归的写法要比采用循环的写法要易懂很多。本文将使用C++实现并查集并使用“按秩合并”和”路径压
（并查集）朋友圈
02-15 475
  某学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有着一定相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。请编写程序计算最大朋友圈中有多少人。 输入格式: 输入的第一行包含两个正整数N（≤30000）和M（≤1000），分别代表学校的学生总数和俱乐部的个数。后...
并查集(朋友圈)
我有一个梦想
10-08 505
每对朋友都存在pair中 #include #include #include using namespace std; static int p[100]; int Find(int x)          //返回x的父节点 { if(p[x]!=x) p[x]=Find(p[x]); //这两步包含了路径压缩     return p[x];   }
zz POJ 并查集 题目汇总
weixin_33946605的博客
04-22 183
POJ 并查集 题目汇总: http://hi.baidu.com/czyuan_acm/blog/item/531c07afdc7d6fc57cd92ab1.html 继续数据结构的复习，本次的专题是：并查集。 并查集，顾名思义，干的就是“并”和“查”两件事。很多与集合相关的操作都可以用并查集高效的解决。 两个操作代码： int...
朋友圈（并查集）
罗马尼亚硬拉
09-02 393
本文主要分为三个部分。第一部分是“朋友圈”一题的解题过程，第二部分是并查集的相关知识点，第三部分是向量和数组的相关知识点。
leetcode547. 朋友圈_C++_Med
annabelle1130的博客
09-15 565
班上有N名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B的朋友，B 是 C的朋友，那么我们可以认为 A 也是 C的朋友。所谓的朋友圈，是指所有朋友的集合。 给定一个N * N的矩阵M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。 示...
C++ 求朋友圈的个数 并查集方法
weixin_44208324的博客
03-30 777
有N个同学，他们之间有些是朋友，有些不是。“友谊”是可以传递的，例如A和B是朋友，B和C是朋友，那么A与C也是朋友；朋友圈就是完成“友谊”传递后的一组朋友。给定N*N的矩阵代表同学间是否是朋友，如果M[i][j]=1代表第i个学生与第j个学生是朋友，否则不是。求朋友圈的个数。 例如： Input: [[1,1,0], [1,1,0], [0,0,1]] Output:2 Input: [[1,1,...
并查集与最小生成树原理及C++实现
"并查集与最小生成树是图论中的两种重要算法，分别用于处理不相交集合的合并与查询，以及找到一个图的最小生成树。本文将介绍这两种算法的原理并提供C++实现。 并查集是一种数据结构，主要用于解决不相交集合的合并...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值