并查集的优化

在上期的文章中我们把并查集的具体操作写了出来，写完之后的代码时间复杂度

Find()函数为O(log2n)
Union()函数为O(nlog2n)

这在我们常规的数据结构算法中的时间复杂度已经很小了，但是如果我们在并查集中多次的查找和合并的话，时间复杂度还是很大，今天我给大家介绍一种在足够多的使用查找和合并的情况下的一种时间复杂度非常小的算法:

代码如下:

#include<stdio.h>
#include<stdbool.h>
#include<limits.h>
#define SIZE 13 //假设长度为13
typedef struct Node
{
char data;//数据域
int parent;//父结点
}Node;
typedef struct Gather
{
Node arr[SIZE];//数组长度
}Gather;
//初始化集合
void Initial(Gather* S)
{
int i = 0;
for (i = 0; i < SIZE; i++)
{
S->arr[i].parent = -1;//都设置为-1，每一个结点都是一个独立的集合
}
}
//插入结点
bool EnNode(Gather* S)
{
int i = 0;
for (i; i < SIZE; i++)
S->arr[i].data = 'A' + i;//依次插入A-M
return true;
}

//查找结点的所属的集合
int Find(Gather* S, int x)
{
if (S == NULL)
return INT_MIN;
//优化前的方案
//while (S->arr[x].parent >= 0)//如果父节点不是根结点
//    x = S->arr[x].parent;//一直向上找

//优化后方案
//查找根结点
int root = x;
while (S->arr[root].parent >= 0)
root = S->arr[root].parent;

//把路径上的结点直接连接到根结点
while (x != root)
{
int t = S->arr[x].parent;
S->arr[x].parent = root;
x = t;
}
return root;
}
//合并两棵树所属的集合
bool Union(Gather* S, int x, int y)
{
if (S == NULL)
return false;
int Root1 = Find(S, x);
int Root2 = Find(S, y);
if (Root1 == Root2)
return false;//如果是同一个集合则直接返回
if (S->arr[Root2].parent > S->arr[Root1].parent)//代表Root1中元素大于Root2中的元素
{
S->arr[Root1].parent += S->arr[Root2].parent;//把Root2中的结点数量加到Root1中
S->arr[Root2].parent = Root1;//将Root2连接到Root1上
}
if (S->arr[Root2].parent <= S->arr[Root1].parent)//代表Root2中元素大于Root1中的元素
{
S->arr[Root2].parent += S->arr[Root1].parent;//把Root2中的结点数量加到Root1中
S->arr[Root1].parent = Root2;//将Root2连接到Root1上
}
return true;
}

int main()
{
Gather S;
Initial(&S);//初始化结点
EnNode(&S);//插入结点
//建立链接
Union(&S, 0, 1);
Union(&S, 1, 4);
Union(&S, 1, 5);
Union(&S, 4, 10);
Union(&S, 4, 11);

    Union(&S, 2, 6);

    Union(&S, 3, 7);
Union(&S, 3, 8);
Union(&S, 3, 9);
Union(&S, 7, 12);

    //合并其他树
Union(&S, 6, 4);//合并两个树
Union(&S, 0, 3);//全部合并

return 0;
}

相比于上期的代码，主要修改了Find函数的中操作，具体思想是:

先找到根结点，再将查找路径上所有节点都挂到根结点下

这样做在调用Find函数足够多的情况下时间复杂度不会超过O(5)

具体Find的时间复杂度为O(α(n))

具体Union的时间复杂度为O(nα(n))

α(n)是一种增长速度及其缓慢的函数，为阿克曼函数的反函数，这涉及到计算机科学和数学的内容，总之假设n = 10⁸⁰(宇宙的原子数量),Find(α(n))的复杂度也不会大于O(5)