不相交集的求并算法（按集合大小求并+按高度求并）

最新推荐文章于 2023-09-04 23:40:40 发布
最新推荐文章于 2023-09-04 23:40:40 发布
阅读量2.8k 收藏 5
点赞数 1
分类专栏： (1)dataStructure&Alg 文章标签： 数据结构 不相交集合求并
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PacosonSWJTU/article/details/49717009
版权

【0】README

0.1）本文总结于 数据结构与算法分析， 但源代码均为原创，旨在实现 不相交集ADT的两个操作：合并集合union+查找集合find；
0.2） 不相交集ADT 的 Introduction ， 参见 http://blog.csdn.net/PacosonSWJTU/article/details/49716905

【1】灵巧求并算法——按集合大小求并

1.1）大小求并法定义：上面的Union执行是相当任意的， 通过使第二棵树 成为第一棵树的子树而完成合并；对其的改进是借助任意的方法打破现有关系， 使得总让较小的树成为较大树的子树，我们把这种方法叫做 大小求并法；
1.2）可以看到， 如果Union 操作都是按照大小求并的话，那么任何节点的深度均不会超过 logN；
1.3）首先注意节点的深度为0， 然后它的深度随着一次 Union 的结果而增加的时候，该节点则被置于至少是 它以前所在树两倍大的一棵树上；因此，它的深度最多可以增加 logN次；

  • 1.3.2） Find 操作 的运行时间为 O（logN）， 而连续M次操作则花费 O（MlogN）；
  • 1.3.3） 下图指出在16次Union操作后可能得到这种最坏的树；而且如果所有的Union都对相等大小的树进行， 那么这样的树是会得到的；
    这里写图片描述

1.4）为了实现这种方法， 我们需要记住每个树的大小。由于我们实际上只使用一个数组，因此可以让每个根的数组元素包含它 的树的大小的负值；
1.5）已经证明：若使用按大小求并则连续 M次运算需要 O（M）平均时间， 这是因为 当随机的Union执行时， 整个算法一般只有一些很小的集合（通常是一个元素）与 大 集合 合并；

1.6）souce code + printing

  • 1.6.1）download source code ：
    https://github.com/pacosonTang/dataStructure-algorithmAnalysis/blob/master/chapter8/p203_unionBySize.c
  • Source Code Statements：
    • S1）显然，本源代码只对元素的size进行了加，没有减；因为我想的话， 元素只能合并一次，也即是元素C起初合并到了集合A，就不能再次合并到集合B， 元素C就一直属于集合A的子集了；
    • S2）当然，这个代码只是 大致上实现了按大小求并的思想，如果元素C还可以再次合并到其他集合的话，这就涉及到集合根元素的size的加减问题了；需要的话，添加之即可；
  • 1.6.2）souce code at a glance
#include <stdio.h>
#include <malloc.h>

#define ElementType int
#define Error(str) printf("\n error: %s \n",str) 

struct UnionSet;
typedef struct UnionSet* UnionSet;

// we adopt the child-sibling expr
struct UnionSet
{
    int parent;
    int size;
    ElementType value;
};

UnionSet makeEmpty(); 
UnionSet* initUnionSet(int size, ElementType* data);
void printSet(UnionSet* set, int size);
void printArray(ElementType data[], int size);
int find(ElementType index, UnionSet* set);

// initialize the union set 
UnionSet* initUnionSet(int size, ElementType* data)
{
    UnionSet* set;  
    int i;

    set = (UnionSet*)malloc(size * sizeof(UnionSet));
    if(!set)
    {
        Error("out of space, from func initUnionSet");        
        return NULL;
    }   

    for(i=0; i<size; i++)
    {
        set[i] = makeEmpty();
        if(!set[i])
            return NULL;
        set[i]->value = data[i];
    }

    return set;
}

// allocate the memory for the single UnionSet and evaluate the parent and size -1
UnionSet makeEmpty()
{
    UnionSet temp;

    temp = (UnionSet)malloc(sizeof(struct UnionSet));
    if(!temp)
    {
        Error("out of space, from func makeEmpty!");        
        return NULL;
    }

    temp->parent = -1;
    temp->size = 1;
    return temp;
}

// merge set1 and set2 by size
void setUnion(UnionSet* set, int index1, int index2)
{
    //judge whether the index1 or index2 equals to -1 ,also -1 represents the root
    if(index1 != -1)
        index1 = find(index1, set);
    if(index2 != -1)
        index2 = find(index2, set);

    if(set[index1]->size > set[index2]->size)
    {
        set[index2]->parent = index1;
        set[index1]->size += set[index2]->size;
    }
    else
    {
        set[index1]->parent = index2;
        set[index2]->size += set[index1]->size;
    }
} 

//find the root of one set whose value equals to given value
int find(ElementType index, UnionSet* set) 
{
    UnionSet temp;  

    while(1)
    {
        temp = set[index];
        if(temp->parent == -1)
            break;
        index = temp->parent;
    }

    return index;       
}   

int main()
{
    int size;
    UnionSet* unionSet;
    ElementType data[] = {110, 245, 895, 658, 321, 852, 147, 458, 469, 159, 347, 28};

    size = 12;
    printf("\n\t====== test for union set by size ======\n");
    //printf("\n\t=== the initial array is as follows ===\n");
    //printArray(data, size); 

    printf("\n\t=== the init union set are as follows ===\n");
    unionSet = initUnionSet(size, data); // initialize the union set over
    printSet(unionSet, size);

    printf("\n\t=== after union(1,5) + union(2,5) + union(3,4) + union(4,5) ===\n");
    setUnion(unionSet, 1, 5);
    setUnion(unionSet, 2, 5);
    setUnion(unionSet, 3, 4);
    setUnion(unionSet, 4, 5);
    printSet(unionSet, size);

    printf("\n\t=== after union(9,8) + union(7,6) + union(3,6) ===\n");
    setUnion(unionSet, 9, 8);
    setUnion(unionSet, 7, 6);
    setUnion(unionSet, 3, 6);   
    printSet(unionSet, size);

    return 0;
}

void printArray(ElementType data[], int size)
{
    int i;

    for(i = 0; i < size; i++)    
        printf("\n\t data[%d] = %d", i, data[i]);                    
    printf("\n\n");
} 

void printSet(UnionSet* set, int size)
{
    int i;
    UnionSet temp;

    for(i = 0; i < size; i++)
    {       
        temp = set[i];
        printf("\n\t parent[%d] = %d", i, temp->parent);                
    }
    printf("\n");
}
  • 1.6.3）printing result
    这里写图片描述

【2】灵巧求并算法——按集合高度求并

2.1）按高度求并定义： 另外一种方法是按照高度求并（按照高度求并是按大小求并的简单修改）（推荐）；
2.2）它同样保证所有的树的深入最多是 O（logN)。我们使得 浅的树 成为深 的树的子树，这是一种平缓算法， 因为只有当两颗相等深度的树求并时树的高度才会增加（此时树的高度增加1）。
2.3）source code + printing result

#include <stdio.h>
#include <malloc.h>

#define ElementType int
#define Error(str) printf("\n error: %s \n",str) 

struct UnionSet;
typedef struct UnionSet* UnionSet;

// we adopt the depth-sibling expr
struct UnionSet
{
    int parent;
    int height;
    ElementType value;
};

UnionSet makeEmpty();
UnionSet* initUnionSet(int depth, ElementType* data);
void printSet(UnionSet* set, int depth);
void printArray(ElementType data[], int depth);
int find(ElementType index, UnionSet* set);

// initialize the union set 
UnionSet* initUnionSet(int size, ElementType* data)
{
    UnionSet* set;  
    int i;

    set = (UnionSet*)malloc(size * sizeof(UnionSet));
    if(!set)
    {
        Error("out of space, from func initUnionSet");        
        return NULL;
    }   

    for(i=0; i<size; i++)
    {
        set[i] = makeEmpty();
        if(!set[i])
            return NULL;
        set[i]->value = data[i];
    }

    return set;
}

// allocate the memory for the single UnionSet and evaluate the parent and depth -1
UnionSet makeEmpty()
{
    UnionSet temp;

    temp = (UnionSet)malloc(sizeof(struct UnionSet));
    if(!temp)
    {
        Error("out of space, from func makeEmpty!");        
        return NULL;
    }

    temp->parent = -1;
    temp->height = 0;
    return temp;
}

// merge set1 and set2 by depth
void setUnion(UnionSet* set, int index1, int index2)
{
    //judge whether the index1 or index2 equals to -1 ,also -1 represents the root
    if(index1 != -1)
        index1 = find(index1, set);
    if(index2 != -1)
        index2 = find(index2, set);

    if(set[index1]->height > set[index2]->height)   
        set[index2]->parent = index1;           
    else if(set[index1]->height < set[index2]->height)  
        set[index1]->parent = index2;       
    else
    {
        set[index1]->parent = index2;
        set[index2]->height++; // only if the height of both of subtrees is equal, the height increases one
    }
} 

//find the root of one set whose value equals to given value
int find(ElementType index, UnionSet* set) 
{
    UnionSet temp;  

    while(1)
    {
        temp = set[index];
        if(temp->parent == -1)
            break;
        index = temp->parent;
    }

    return index;       
}   

int main()
{
    int size;
    UnionSet* unionSet;
    ElementType data[] = {110, 245, 895, 658, 321, 852, 147, 458, 469, 159, 347, 28};

    size = 12;
    printf("\n\t====== test for union set by depth ======\n");
    //printf("\n\t=== the initial array is as follows ===\n");
    //printArray(data, depth); 

    printf("\n\t=== the init union set are as follows ===\n");
    unionSet = initUnionSet(size, data); // initialize the union set over
    printSet(unionSet, size);

    printf("\n\t=== after union(0, 1) + union(2, 3) + union(4, 5) + union(6, 7) + union(8, 9) + union(10 ,11) ===\n");
    setUnion(unionSet, 0, 1);
    setUnion(unionSet, 2, 3);
    setUnion(unionSet, 4, 5);
    setUnion(unionSet, 6, 7);
    setUnion(unionSet, 8, 9);   
    setUnion(unionSet, 10, 11); 
    printSet(unionSet, size);

    printf("\n\t=== after union(1, 3) + union(5, 7) + union(9, 11) ===\n");
    setUnion(unionSet, 1, 3);
    setUnion(unionSet, 5, 7);
    setUnion(unionSet, 9, 11);
    printSet(unionSet, size);  

    printf("\n\t=== after union(3, 7) + union(7, 11) ===\n");
    setUnion(unionSet, 3, 7);
    setUnion(unionSet, 7, 11);  
    printSet(unionSet, size); 

    return 0;
}

void printArray(ElementType data[], int size)
{
    int i;

    for(i = 0; i < size; i++)    
        printf("\n\t data[%d] = %d", i, data[i]);                    
    printf("\n\n");
} 

void printSet(UnionSet* set, int size)
{
    int i;
    UnionSet temp;

    for(i = 0; i < size; i++)
    {       
        temp = set[i];
        printf("\n\t parent[%d] = %d", i, temp->parent);                
    }
    printf("\n");
}
  • 2.3.3）printing results：
    这里写图片描述
tomjourney
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
不相交集合-并查集
等价交换
07-18 1380
并查集的定义不相交集合维护了一个不相交动态集的集合。我们用一个代表来标示每个集合，而这个代表是这个集合的某个成员。 该集合中最主要的两个操作Union（合并）与Find（查询），因此该数据结构也叫做并查集。让我们看一下百度百科的介绍： 在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个
不相交集合的合并
人总是要有梦想的QAQ的博客
04-02 329
#include <iostream> using namespace std; int parent[1000], a[1000]; void unionArray(int i, int j) { int x = parent[i] + parent[j]; if(parent[i] > parent[j]) { // i的节点少 pare...
不相交集（并查集）
beichengll的博客
08-09 2698
1、不相交集是一种解决等价问题的有效数据结构，这种数据结构实现起来非常简单，每个例程只要几行代码，而且可以使用一个简单的数组实现。实现也非常快，每种操作只需要常数平均时间。2、等价关系 等价关系必须满足下面三个性质： (1):自反性，对于集合S中的任意元素a，a R a;(R为定义的关系，比如R为<=， >=等等) (2);对称性,a R b当且仅当b R a (3):传递性，若a R
一些灵巧的求并算法
weixin_34399060的博客
10-13 75
1 class DisjSets 2 { 3 public: 4 explicit DisjSets(int numElements); 5 int find(int x)const; 6 int find(int x); 7 void unionSets(int root1, int root2); 8 private: 9 ...
不相交ADT 灵巧求并算法
Ho_mu_ra的博客
05-12 426
回忆上一次文章中，Union操作并没有规定具体让哪棵树成为为另一棵树的子树。由此可以看出，该Union操作是任意的，我们如果想要对数据进行寻找等操作就会显得无迹可寻。同时，该方法的合并并没有合并到一棵树的根节点上，思考：当合并到原本的树的最深的节点时，合并后的深度无疑为大大增加，这样就会使得后续的 Find 和 Union 花费更多的时间。因此，出现了两种改进该Union的方法。 其一、按大小求并（union-by-size)。顾名思义，该方法将含有节点的数目更少的树合并另一棵到根节点上。 对于这种方法
河南省陕州中学2015届高三数学下学期第一次月考试题 文（答案不全）
08-19
补集表示不属于集合P的所有元素组成的集合，交集表示同时属于P和Q的元素组成的集合。 2. **复数运算**：题目中要求计算复数的乘积并找出虚部。复数的乘法遵循代数乘法法则，而虚部是指复数中带有i的部分。 3. **...
bemolang:支持Sets的C语言子集的语言实现
04-05
在C语言中，集合这一概念并不存在。传统的C语言主要提供了基本数据类型如int、float、char等，以及数组、结构体和指针等复合数据结构。然而，集合是一种高效的数据组织方式，它允许程序员存储和操作一组不重复的元素...
yafmp:又一个模糊匹配程序
05-30
Jaccard相似度则关注两个集合的交集大小相对于并集大小的比例，用于衡量字符串的相似性。Hamming距离则是指两个等长字符串在相同位置上的不同字符数量。 在实际应用中，yafmp可能提供了丰富的参数设置，以适应不同...
2019年高考数学专题05高考考前调研卷五
08-06
1. **集合的基本运算**：题目中提到了集合A和集合B的交集AB，这是集合论中的基本概念。交集表示的是同时属于集合A和集合B的所有元素组成的集合。在这个例子中，求解了A和B的交集，并给出了正确答案。 2. **复数运算...
高中高三数学联考试题解析 文 (教师版) 试题.doc
11-01
1. **集合的基本概念**：题目中提到了集合M与N的交集，这涉及到集合论的基础知识，交集表示同时属于M和N的元素集合。在题目中，由于2是M与N的交集中的元素，这意味着2既在M也在N中。 2. **三角函数及象限性质**：第...
Union-Find 按大小求并算法
路漫漫其修远兮，吾将上下而求索
12-27 1002
#include #include using namespace std; class UF{   public:     UF(int size): vec(size), parent(size) {       for (int i = 0; i         vec[i] = i;         parent[i] = -1;       }     }     void Uni
不相交集的find和union
豆子的collection
12-24 1352
两个不相交集合是指S1 ∩ S2 == {}空集，一般包含两个操作，find和union操作 find:返回包含给定元素的集合 union把两个集合合并成一个集合 这里只用到了数组来表示这个数据结构，这个数组中保存着每个元素的等价类的名字 #include #include using namespace std; class DisjSets { public: explicit
不相交集ADT
零丁若叹
03-23 1660
1.不相交集是解决等价关系的一种数据结构，执行合并和查找的速度都非常快，M次运行合并和查找的运行时间为（M*logN）。 2.不相交集ADT支持三种操作： Union操作：把两个集合合并 Find操作：查找某个元素所在集合的名字，两个元素x,y在同一个集合中的充要条件是Find(x)和Find(y)返回的结果相同。 Set操作：生成若干个集合 不相交集的初始操作代码为： void in
并查集
约定的博客
02-09 292
定义并查集也是不相交集，存放数据的集合关系，如{1,2} {3,4,6} {5}。输入数据最初是N个集合，每个集合含有一个元素。初始的描述是所有的关系均为false。每个集合含有一个元素，这使得这些集合不相交。 ADT: 　建立新集合 　查找某个元素属于哪个集合 　合并两个集合 时间复杂度O(1)集合S上的关系如果对于每一对元素(a,b)，a,b∈Sa ,b\in S,aRb或者为true
数据结构 7并查集(DISJOINT SET)
vxxm的博客
03-16 796
不相交集ADT 等价关系 若对于每一对元素(a,b),a,b∈S，aRb或者为true或者为false,则称集合S上定义关系R。如果aRb为true,那么我们说a与b有关系。 等价关系是满足下列三个性质的R： （1）自反性 对与所有的a∈S，aRa （2）对称性 aRb 当且仅当 bRa （3）传递性 若aRb 且 bRc 则 aRc 动态等价性问题 如果有一个集合S，...
[高级数据结构C++] 并查集（合并，路径压缩，加权）
最新发布
qq_73928885的博客
09-04 231
主要用于处理一些`不相交集合的合并问题` 经典的应用：`连通图`，`最小生成树 Kruskal 算法`，最近公共祖先`LCA算法`
不相交集类 (并查集)
小米子的成长日记
07-20 469
不相交集类是的一种有效的数据结构，其实现简单，可以使用一个简单的数组，而且每种操作只需要常数时间。本章描述了等价关系、动态等价性问题、并查集基本数据结构、按大小求并和按高度求并算法以及路径压缩，附带实现代码...
算法竞赛基础训练题_判断题
热门推荐
国家一级致癌物
12-11 1万+
算法竞赛基础训练题 判断题 The major task of algorithm analysis is to analyze the time complexity and the space complexity. 算法分析的主要任务是分析时间复杂度和空间复杂度。T For a sequentially stored linear list of length N, the time complexities for query and insertion are O(1) and O(N), res

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值