并查集（孩子指向父亲的树结构）

最新推荐文章于 2022-01-14 23:17:09 发布
最新推荐文章于 2022-01-14 23:17:09 发布
阅读量791 收藏 16
点赞数 5
分类专栏： 玩转数据结构和算法 文章标签： 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36925536/article/details/87273625
版权

目录

并查集实现哪些功能

 并查集接口

 使用数组实现并查集

 并查集size优化

并查集深度优化

并查集路径压缩优化

 

  • 并查集实现哪些功能

 

  •  并查集接口

package com.suanfa.unionfind;
/**
 * 并查集接口，并查集是一种孩子指向父亲的树结构
 * @author Administrator
 *
 */
public interface UF {
	//并查集元素个数
    int getSize();
    //判断两个元素是否所属一个集合，是否可以连接
    boolean isConnected(int p, int q);
    //把两个元素并在一起
    void unionElements(int p, int q);
}

  •  使用数组实现并查集

 

package com.suanfa.unionfind;

// 我们的第一版Union-Find并查集
public class UnionFind1 implements UF {

    private int[] id;    // 我们的第一版Union-Find本质就是一个数组

    public UnionFind1(int size) {

        id = new int[size];

        // 初始化, 每一个id[i]指向自己, 没有合并的元素
        for (int i = 0; i < size; i++)
            id[i] = i;
    }

    @Override
    public int getSize(){
        return id.length;
    }

    // 查找元素p所对应的集合编号
    // O(1)复杂度
    private int find(int p) {
        if(p < 0 || p >= id.length)
            throw new IllegalArgumentException("p is out of bound.");

        return id[p];
    }

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

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

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

        if (pID == qID)
            return;

        // 合并过程需要遍历一遍所有元素, 将两个元素的所属集合编号合并
        for (int i = 0; i < id.length; i++)
            if (id[i] == pID)
                id[i] = qID;
    }
}
package com.suanfa.unionfind;
// 我们的第二版Union-Find并查集
public class UnionFind2 implements UF {

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

    // 构造函数
    public UnionFind2(int size){

        parent = new int[size];

        // 初始化, 每一个parent[i]指向自己, 表示每一个元素自己自成一个集合
        for( int i = 0 ; i < size ; i ++ )
            parent[i] = i;
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        // 不断去查询自己的父亲节点, 直到到达根节点
        // 根节点的特点: parent[p] == p
        while(p != parent[p])
            p = parent[p];
        return p;
    }

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

    // 合并元素p和元素q所属的集合
    // O(h)复杂度, h为树的高度
    @Override
    public void unionElements(int p, int q){
    	//结合树形图理解
        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        parent[pRoot] = qRoot;
    }
}

  •  并查集size优化

 

package com.suanfa.unionfind;
// 我们的第三版Union-Find并查集，通过节点个数进行优化，节点个数少的合并到节点个数多的上面
public class UnionFind3 implements UF{

    private int[] parent; // parent[i]表示第一个元素所指向的父节点
    private int[] sz;     // sz[i]表示以i为根的集合中元素个数

    // 构造函数
    public UnionFind3(int size){

        parent = new int[size];
        sz = new int[size];

        // 初始化, 每一个parent[i]指向自己, 表示每一个元素自己自成一个集合
        for(int i = 0 ; i < size ; i ++){
            parent[i] = i;
            sz[i] = 1;
        }
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        // 不断去查询自己的父亲节点, 直到到达根节点
        // 根节点的特点: parent[p] == p
        while( p != parent[p] )
            p = parent[p];
        return p;
    }

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

    // 合并元素p和元素q所属的集合
    // O(h)复杂度, h为树的高度
    @Override
    public 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{ // sz[qRoot] <= sz[pRoot]
            parent[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }
}

  • 并查集深度优化

 

package com.suanfa.unionfind;
// 我们的第四版Union-Find并查集，通过深度进行优化，把深度小的树合并到深度大的树上
public class UnionFind4 implements UF {

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

    // 构造函数
    public UnionFind4(int size){

        rank = new int[size];
        parent = new int[size];

        // 初始化, 每一个parent[i]指向自己, 表示每一个元素自己自成一个集合
        for( int i = 0 ; i < size ; i ++ ){
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        // 不断去查询自己的父亲节点, 直到到达根节点
        // 根节点的特点: parent[p] == p
        while(p != parent[p])
            p = parent[p];
        return p;
    }

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

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

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

        if( pRoot == qRoot )
            return;

        // 根据两个元素所在树的rank不同判断合并方向
        // 将rank低的集合合并到rank高的集合上
        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的值
        }
    }
}

  • 并查集路径压缩优化

 

package com.suanfa.unionfind;
// 我们的第五版Union-Find并查集，路径压缩优化
public class UnionFind5 implements UF {

    // rank[i]表示以i为根的集合所表示的树的层数
    // 在后续的代码中, 我们并不会维护rank的语意, 也就是rank的值在路径压缩的过程中, 有可能不在是树的层数值
    // 这也是我们的rank不叫height或者depth的原因, 他只是作为比较的一个标准
    private int[] rank;
    private int[] parent; // parent[i]表示第i个元素所指向的父节点

    // 构造函数
    public UnionFind5(int size){

        rank = new int[size];
        parent = new int[size];

        // 初始化, 每一个parent[i]指向自己, 表示每一个元素自己自成一个集合
        for( int i = 0 ; i < size ; i ++ ){
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        while( p != parent[p] ){
            parent[p] = parent[parent[p]];//路径优化核心代码
            p = parent[p];
        }
        return p;
    }

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

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

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

        if( pRoot == qRoot )
            return;

        // 根据两个元素所在树的rank不同判断合并方向
        // 将rank低的集合合并到rank高的集合上
        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的值
        }
    }
}

 

百味皆苦
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的节点包含指向父节点的指针，给出树中一个元素，求出中序遍历的下一个元素
shen19960603的博客
08-20 1131
package Tree; public class SearchForNext { /** * 树的节点有指向父节点,寻找下一个中序遍历的节点 */ public static NodeWithParent searchForNext(NodeWithParent now){ if(now.rchild != null) { ...
c语言数据结构之并查集 总结
12-31
并查集(Union-Find Set)： 一种用于管理分组的数据结构。它具备两个操作：(1)查询元素...并查集的核心在于，一棵树的所有节点根节点都为一个节点。使用Find函数查询时，也是查询到这个节点的根节点。 一行并查集： int
并查集
weixin_43414877的博客
04-23 160
并查集 并查集的全称是合并-查找集合，顾名思义它的主要功能就是合并查找。 合并：合并两个不相交的集合； 查找：查找两个元素是否在同一个集合中。 并查集是一个集合，但是其逻辑上的结构却类似一个树，主要表现为：每一个元素都对应着一个parent结点。我们查找的实质，就是查找元素对应的根结点；合并的操作，也是对被合并的集合元素的根进行修改。（在实际操作中，我们会让parent直接对应根结点，后文在“路径压缩”中会讲到）但是在实际操作中，我们只需要把parent值存在数组中，只要做到“心中有树”即可。 我们用一个简
用父亲结点数组实现并查集
weixin_33688840的博客
12-02 201
1 #include&lt;stdio.h&gt; 2 #include&lt;stdlib.h&gt; 3 #include&lt;algorithm&gt; 4 using namespace std; 5 typedef struct ufset *UFset; 6 struct ufset 7 { 8 int parent[100001]; ...
子节点带有指向父节点指针的二叉树拷贝算法
qq_15054345的博客
12-25 855
若二叉树中带有指向父节点指针，则二叉树的拷贝算法需要使用后续遍历，代码如下： struct Node { int data; Node* lchild; //左孩子指针 Node* rchild; //右孩子指针 Node* parent; //父节点指针 }; Node* copy(Node *p)//拷贝二叉树函数 { if (NULL == p) r...
并查集——（一）概述
努力中的老周的专栏
09-28 374
并查集概念 在计算机科学中，并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。 并查集数据结构表示 常用的并查集实现有两种方法。 使用数组 我们使用数组来表示这样的数据结构。 比如，我们知道这个集合最大元素个数为 10^5 个，也就是 1 ~ 10^5。那么我们可以定义一个数组来记录每个元素的父节点。 const int MAXN=1e5+4; int parent[MAXN]; memset(parent, -1, sizeof(parent))
并查集与最小生成树 原理讲解、c++代码
10-13
并查集是一种树形数据结构，主要用于处理不相交集合的合并与查询。在实际问题中，例如强盗帮派的场景，我们可以用并查集来判断两个成员是否属于同一个帮派。它不强调结构，但常用数组实现，通过一个标记数组`father`...
并查集基础(C++版).pptx
01-10
- **并查集**：它是一个树形结构，用来处理不相交集合的合并和查询。例如，可以用于判断森林中的树的数量或者判断两个节点是否属于同一棵树。 - **数组pre[]**：记录每个节点的前驱节点，也就是它们所属集合的根...
Leetcode 并查集详解
最新发布
03-08
2. **解决最小生成树算法中的边选择问题**：在实现Kruskal算法等最小生成树算法时，使用并查集可以帮助有效地避免形成环路，从而确保生成的树是最小生成树。 3. **在社交网络中判断两个人是否是朋友关系**：在社交...
[一篇看懂]啥是并查集、咋写并查集（附例题）
陈浩的博客
01-05 542
1. 并查集 -** 并查集说到底就是个多叉树** 1.1. 并查集应用 找连通分量 kruscal最小生成树的存储结构 求最近公共祖先（Least Common Ancestors, LCA） 1.2. 怎么写一个并查集 并查集三大部分 初始化 找根 合并: 其中一个根下放另一个并查集的根 1.2.1. 初始化 parent数组全置为-1 parent中存储的如果是非负数: 存的...
并查集 ——数组实现
pursue_my_life的博客
04-24 3317
并查集作用：        1. 用来合并集合元素，并确定结合数量，查寻元素属于哪个集合。        2. 在图结构里（图里的点便是元素），确定两点是否处于联通状态，应用举例：          eg：    集合个数     Hdu 畅通工程                     最小生成树  Hdu 还是畅通工程#include &lt;iostream&gt; #include &l...
并查集union时需要findparent么（持续更新中...）
chiyimai0460的博客
02-25 91
并查集union时需要findparent么？答案是需要 转载于:https://my.oschina.net/u/1421373/blog/379957...
[图解算法]并查集
飞鱼の博客
02-04 647
一文读懂并查集  假设你现在置身于一个鸡尾酒会中，任何人都不能通过直接搭讪来获得陌生漂亮妹子的微信号。于是你委托你的朋友帮忙，你的朋友委托他的朋友。。。直到找到一位与漂亮妹子认识的人拿到了微信号。因此，你通过这些中间朋友与妹子取得了联系，成功进入了她的社交圈。当然，你可以通过她认识跟多的漂亮妹子，走上人生巅峰。  但是设想一下这样一个悲剧，那位漂亮妹子刚来到地球，她与地球上所有的人类都没有联系...
并查集——父亲儿子傻傻分不清
qq_42323600的博客
04-12 256
算法板子记录第一天：并查集（找爸爸） 并查集，处理不相交集的合并和查询的数据结构，俗称：找爸爸 最先写这个数据结构就是他使用的存储结构最简单，一个数组搞定，当然有别的需要可以另加嘛 int num; //节点数量 int fa[num*2]; //存储节点的上级 int rank[num]; //每个节点的高度 初始化父亲数组 void init(){ for(int...
数据结构之并查集
AryCra_07的博客
01-14 899
并查集——一种优雅简洁的数据结构
带有父节点指针的二叉树找前驱节点和后继节点
qq_42766680的博客
03-10 818
带有父节点指针的二叉树找前驱节点和后继节点 题目：给一个正常的二叉树节点类型加一个指向父节点的指针parent。找其中某一个节点的前驱节点和后继节点 *分析：所为前驱节点和后继节点就是找中序遍历。 答：找出一个结点出现的所有可能性并进行操作。可分为下面几种出现的情况 1. 如果该结点无左右子树，判读该结点是否有父节点？ 1.1 如果有父节点，则判断该节点为父节点的左、右子树？ 1.1.1 如果为左子树则该父节点就是其后继节点 1.1.2 如果为右子
算法第四版第一章
weixin_41888669的博客
10-23 156
public class UF { private int[] id; private int count; public UF(int N){ // 初始化分量Id数组 count=N; id= new int[N]; for (int i = 0; i &lt;N ; i++) { ...
使用Kruskal算法与并查集求解最小生成树
并查集，又称为离散集合，是一种数据结构，主要处理不相交集合的合并和查询问题。在并查集中，每个元素属于一个集合，可以通过“父亲”节点来表示集合的关系。初始状态下，每个元素都是独立的集合。并查集提供了两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值