# 并查集（一种技巧）

• 实用的树形数据结构
• 主要处理不相交集合的查询与合并
• 选出集合中的某个元素为代表，集合中具体包含哪些元素不重要
• 将如下一系列操作复杂度降到常数级：对于给定的元素，可以很快找到该元素所在集合可以很快合并两个元素所在集合
• 用树根当一系列数字的代表
• 初始化函数的目的是使每个元素都是以自身为代表

表示：

不交集森林把每一个集合以一棵树表示，每一个节点即是一个元素。节点保存着到它的父节点的引用，树的根节点则保存一个空引用或者到自身的引用或者其他无效值，以表示自身为根节点。这个数据结构最早由Bernard A. Galler和Michael J. Fischer于1964年提出，但是经过了数年才完成了精确的分析。

优化：路径压缩

将长链压缩为较少层数

SHOW ME THE CODE

#include<stdio.h>
#define MAXSIZE 5
//为举例方便此处以5为最大长度

int uset[MAXSIZE];//定义一个足够长数组,用下标表示节点

/*构造并查集*/
void makeSet(int size);//size为节点数【初始化】
void unite(int x,int y);//【并】
int find(int i);//【查】

int main(int argc, char** argv)
{
    makeSet(MAXSIZE);//初始化一个并查集，使每一个元素指向自己
    unite(3,4);//合并元素3和4

    int i = find(3);//i为3的根节点值
    printf("%d\n",i);
}

void makeSet(int size)
{
    for(int i = 0;i < size; i++) {
        //每一个元素都指向自己，各自为各自的代表
        uset[i] = i;
    }
}

/*找到元素所在集合代表 如果位于同一集合则不合并*/
int find(int i)
{
    if(i == uset[i]){//找代表时代表一直指向自己
        return i;
    }
    return find(uset[i]);
}

void unite(int x,int y)//合并x y
{
    //先找到节点所对应代表
    int i = find(x);
    int j = find(y);
    if(i == j){
        return;//不合并
    }
    uset[i] = j;//i的父节点就是j
}

图解：

• 初始化：（1，2，3等具体数据并不存在，为方便演示加入了数字）

void makeSet(int size)
{
    for(int i = 0;i < size; i++) {
        //每一个元素都指向自己，各自为各自的代表
        uset[i] = i;
    }
}

• 输入代码：

int main(int argc, char** argv)
{
    makeSet(MAXSIZE);
    unite(3,4);
    unite(3,5);
    unite(3,2);
    unite(1,3);
    int i = find(3);
    printf("%d\n",i);
}

• 结构变为：可以发现，数据1，2，3，4，5被合并成了以2为代表的一个集合

但是，观察左侧可以发现这种模式存在弊端，若是查找一个长链上末尾数字的代表时，最大最坏情况下（树退化成一条链时），单次查询的时间复杂度高达O（n），由此，我们引入并查集PIUS——路径压缩后的并查集

并查集的路径压缩

CODE:

#include<stdio.h>

//路径压缩：
/*
因为在特殊状况下 这棵树可能是一个巨长的链，所以设链的最后一个节点为x
每次执行find相当于遍历整个链条
只需把遍历过的节点都改为根的子节点，查询会块很多
*/

#define MAXSIZE 100

int uset[MAXSIZE];//定义一个足够长数组,用下标表示节点

int rank[MAXSIZE];//树的高度

/*构造并查集*/
void makeSet(int size);//size为节点数
int find(int i);
void unite(int x,int y);

int main(int argc, char** argv)
{
    /*可以体现非路径压缩并查集的劣势的情况如下*/
    makeSet(MAXSIZE);
    unite(3,4);
    unite(3,5);
    unite(3,2);
    unite(1,3);
    /*在路径压缩后得到了优化*/
    int i = find(3);
    printf("%d\n",i);
}

void makeSet(int size)
{
    for(int i = 0;i < size; i++) {
        //每一个元素都指向自己，各自为各自的代表
        uset[i] = i;
        //树的高度
        rank[i] = 0;
    }
}

/*找到元素所在集合代表 如果位于同一集合则不合并*/
int find(int i)
{
    if(i == uset[i]){
        return i;
    }
    return uset[i] = find(uset[i]);//在第一次查找时直接将节点连接到根
}

void unite(int x,int y)
{
    //先找到节点所对应代表
    int i = find(x);
    int j = find(y);
    if(i == j){
        return;//不合并
    }
    //判断两棵树的高度 再决定谁为子树
    if (rank[i] < rank[j]){
        uset[i] = j;
    }else{
        uset[j] = i;
        if (rank[i] == rank[j]){
            rank[i]++;
        }
    }
}

路径压缩的核心思想是引入rank，将一个变量抬高后就可以避免长链的形成，有效优化时间复杂度：

图解

• 初始化：（1，2，3等具体数据并不存在，为方便演示加入了数字）

void makeSet(int size)
{
    for(int i = 0;i < size; i++) {
        //每一个元素都指向自己，各自为各自的代表
        uset[i] = i;
        //树的高度
        rank[i] = 0;
    }
}

• 执行

unite(3,4);

• 执行如下代码：

int main(int argc, char** argv)
{
    /*可以体现非路径压缩并查集的劣势的情况如下*/
    makeSet(MAXSIZE);
    unite(3,4);
    unite(3,5);
    unite(3,2);
    unite(1,3);
    /*在路径压缩后很好的得到了优化*/
    int i = find(3);
    printf("%d\n",i);
}

可以发现，数据1，2，3，4，5依旧被合并成了以2为代表的一个集合，虽然主函数代码相同，但是长链的情况消失了 这就是路径压缩的功劳

参考：

1. 并查集--维基百科
2. 算法学习笔记(1) : 并查集