【数据结构】并查集 Find和Union的优化 解析+完整代码

6.2 并查集

6.2.1 并查集基础

• 并查集的概念

  • 并查集的两个基本操作：

    1.查：确定一个指定元素所属集合；

    2.并：将两个不相交的集合合并成一个。

  • 并查集（Disjoint Set）是一种简单的集合表示，支持以下三种函数：

    （1）Initial(S)：将集合S中的每个元素都初始化为只有一个单元素的子集合；

    （2）Union(S,Root1,Root2)：把集合S中的子集合Root2并入子集合Root1，要求Root1和Root2互不相交，否则不支持合并。

    （3）Find(S,x)：查找集合S中单元素x所在的子集合，并返回该子集合的根节点。

• 并查集的存储结构

  用树的双亲表示作为并查集的存储结构，每个子集合以一棵树表示。

  根结点的双亲域为负数。

  

• 并查集基本实现

  • 结构定义

    #define SIZE 100
    int UFSets[SIZE]; //集合元素数组（双亲指针数组）
    

  • 初始化

    void Initial(int S[]){
        for(int i=0;i<SIZE;i++)
            S[i]=-1; //每个元素自成单元素集合
    }
    

  • 查：找到x所属集合，返回x所属根结点

    int Find(int S[],int x){
        while(S[x]>=0) //循环找x的根
            x=S[x];
        return x;
    }
    

    最坏时间复杂度：O(n)

  • 并：将两个集合合并成一个

    void Union(int S[],int Root1,int Root2){
        //要求是不同的集合
        if(Root1==Root2)return;
        //将根Root2连接到另一根Root1下
        S[Root2]=Root1;
    }
    

    时间复杂度：O(1)

6.2.2 并查集Union优化

• 优化思路：

  ∵树越深，越难查找，∴要尽量减小树的深度，

  即 在每次Union操作构建树时，尽量让树长不高。

• 优化的方法：

  1.用根结点的绝对值表示树的结点总数：

2.Union操作时，让小树合并到大树：

//并操作，小树合并到大树
void Union(int S[],int Root1,int Root2){
    if(Root1==Root2)return;
    if(S[Root2]>=S[Root1]){ //Root2结点数更小，是小树
        S[Root1]+=S[Root2]; //累加结点总数
        S[Root2]=Root1; //小树合并到大树
    }
    else{
        S[Root2]+=S[Root1];
        S[Root1]=Root2;
    }
}

该方法构造的树高不超过：$\lfloor lo{g}_{2}n\rfloor +1$

∴ find的时间复杂度变成：$O(lo{g}_{2}n)$

6.2.3 并查集Find优化

• 优化思路：

  Find操作优化（压缩路径）

  压缩路径——Find操作，先找到根结点，再将查找路径上所有结点都挂到根结点下。

  如要查找L结点时：

  

• 优化代码

  //查操作优化：先找到根结点，再进行压缩路径
  int Find(int S[],int x){
      int root=x;
      while(S[root]>=0)root=S[root];//循环找到根
      //压缩路径
      while(x!=root){
          int t=S[x]; //t指向x的父节点
          S[x]=root; //x直接挂到根结点下
          x=t;
      }
      return root; //返回根结点编号
  }
  

• 好处

  每次Find操作，先找根，再压缩路径，可使树的高度不超过$O(a(n))$。$a(n)$是一个增长非常缓慢的函数，对于常见的n值，通常$a(n)<=4$，因此优化后查和并操作开销都低。

• 核心思想：

  还是尽可能让树变矮。

• 优化总结

  

*完整代码 并查集

#include <stdio.h>

#define SIZE 100

int UFSets[SIZE]; // 集合元素数组（双亲指针数组）

// 初始化并查集
void Initial(int S[]) {
    for (int i = 0; i < SIZE; i++)
        S[i] = -1; // 每个元素自成单元素集合
}

// 并操作，小树合并到大树
void Union(int S[], int Root1, int Root2) {
    if (Root1 == Root2) return;
    if (S[Root2] >= S[Root1]) { // Root2结点数更小，是小树
        S[Root1] += S[Root2]; // 累加结点总数
        S[Root2] = Root1; // 小树合并到大树
    } else {
        S[Root2] += S[Root1];
        S[Root1] = Root2;
    }
}

// 查操作优化：先找到根结点，再进行压缩路径
int Find(int S[], int x) {
    int root = x;
    while (S[root] >= 0) root = S[root]; // 循环找到根
    // 压缩路径
    while (x != root) {
        int t = S[x]; // t指向x的父节点
        S[x] = root; // x直接挂到根结点下
        x = t;
    }
    return root; // 返回根结点编号
}

// 输出树的形状
void PrintTreeShape(int S[], int size) {
    printf("Tree Shape:\n");
    for (int i = 1; i <= size; i++) {
        int root = Find(S, i);
        if (root == i) {
            printf("%d <- ", i);
            for (int j = 1; j <= size; j++) {
                if (Find(S, j) == i && j != i) {
                    printf("%d ", j);
                }
            }
            printf("\n");
        }
    }
}

int main() {
    Initial(UFSets); // 初始化并查集

    // 进行一些合并操作
    Union(UFSets, 1, 2);
    PrintTreeShape(UFSets, 5);
    
    Union(UFSets, 3, 4);
    PrintTreeShape(UFSets, 5);
    
    Union(UFSets, 3, 5);
    PrintTreeShape(UFSets, 5);
    
    Union(UFSets, 1, 3);
    PrintTreeShape(UFSets, 5);

    // 打印每个元素的根结点
    for (int i = 1; i <= 5; i++) {
        printf("Element %d's root: %d\n", i, Find(UFSets, i));
    }

    return 0;
}