【轻松掌握数据结构与算法】不相交集合

已于 2025-01-12 14:57:57 修改
阅读量990 收藏 13
点赞数 23
分类专栏： 轻松掌握数据结构与算法 文章标签： 算法 数据结构 cpp
于 2025-01-12 14:51:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Whoisbug/article/details/145093138
版权

引言

不相交集合（Disjoint Sets）是一种数据结构，用于处理一些不相交的集合，并支持两种主要操作：查找（Find）和合并（Union）。这种数据结构在图算法、网络流问题和并查集问题中非常有用。

等价关系和等价类

在数学中，等价关系是一种二元关系，满足自反性、对称性和传递性。等价类是集合中所有相互等价的元素的集合。不相交集合 ADT 可以用来高效地管理和操作这些等价类。

不相交集合 ADT

不相交集合 ADT 定义了以下操作：

  • MakeSet：创建一个新的集合，包含一个元素。

  • Find：查找元素所属的集合。

  • Union：合并两个集合。

应用

不相交集合 ADT 在许多领域都有应用，包括：

  • 图算法：如 Kruskal 最小生成树算法。

  • 网络流问题：用于管理网络中的流量。

  • 并查集问题：用于处理集合的合并和查找操作。

实现不相交集合 ADT 的权衡

不相交集合 ADT 有多种实现方式，每种实现方式都有其优缺点。常见的实现方式包括：

  • 快速合并（Fast UNION）：通过路径压缩优化查找操作。

  • 快速查找（Quick FIND）：通过按秩合并优化合并操作。

快速合并实现（慢查找）

快速合并实现通过路径压缩优化查找操作，使得每次查找操作的时间复杂度接近O(log⁡n)

代码示例
typedef struct DisjointSet {
    int *parent;
    int *rank;
    int size;
} DisjointSet;

// 创建不相交集合
DisjointSet* createDisjointSet(int size) {
    DisjointSet *ds = (DisjointSet*)malloc(sizeof(DisjointSet));
    ds->parent = (int*)malloc(size * sizeof(int));
    ds->rank = (int*)malloc(size * sizeof(int));
    ds->size = size;
    for (int i = 0; i < size; i++) {
        ds->parent[i] = i;
        ds->rank[i] = 0;
    }
    return ds;
}

// 查找元素所属的集合
int find(DisjointSet *ds, int x) {
    if (ds->parent[x] != x) {
        ds->parent[x] = find(ds, ds->parent[x]); // 路径压缩
    }
    return ds->parent[x];
}

// 合并两个集合
void unionSets(DisjointSet *ds, int x, int y) {
    int xRoot = find(ds, x);
    int yRoot = find(ds, y);
    if (xRoot != yRoot) {
        if (ds->rank[xRoot] < ds->rank[yRoot]) {
            ds->parent[xRoot] = yRoot;
        } else if (ds->rank[xRoot] > ds->rank[yRoot]) {
            ds->parent[yRoot] = xRoot;
        } else {
            ds->parent[yRoot] = xRoot;
            ds->rank[xRoot]++;
        }
    }
}

// 释放不相交集合
void freeDisjointSet(DisjointSet *ds) {
    free(ds->parent);
    free(ds->rank);
    free(ds);
}

快速合并实现（快查找）

快速合并实现通过按秩合并优化合并操作，使得每次合并操作的时间复杂度接近O(log⁡n)

代码示例
// 快速合并实现的代码与快速合并实现（慢查找）相同，只是在合并操作中使用按秩合并

#include <stdio.h>
#include <stdlib.h>

// 定义不相交集合结构体
typedef struct DisjointSet {
    int *parent;  // 父节点数组
    int *rank;    // 秩数组，用于优化合并操作
    int size;     // 集合的大小
} DisjointSet;

// 创建不相交集合
DisjointSet* createDisjointSet(int size) {
    DisjointSet *ds = (DisjointSet*)malloc(sizeof(DisjointSet));
    ds->parent = (int*)malloc(size * sizeof(int));
    ds->rank = (int*)malloc(size * sizeof(int));
    ds->size = size;
    for (int i = 0; i < size; i++) {
        ds->parent[i] = i;  // 每个元素的初始父节点是自己
        ds->rank[i] = 0;    // 初始秩为0
    }
    return ds;
}

// 查找元素所属的集合，路径压缩
int find(DisjointSet *ds, int x) {
    if (ds->parent[x] != x) {
        ds->parent[x] = find(ds, ds->parent[x]);  // 路径压缩
    }
    return ds->parent[x];
}

// 合并两个集合，按秩合并
void unionSets(DisjointSet *ds, int x, int y) {
    int xRoot = find(ds, x);
    int yRoot = find(ds, y);
    if (xRoot != yRoot) {
        if (ds->rank[xRoot] < ds->rank[yRoot]) {
            ds->parent[xRoot] = yRoot;  // 将秩较小的树合并到秩较大的树上
        } else if (ds->rank[xRoot] > ds->rank[yRoot]) {
            ds->parent[yRoot] = xRoot;  // 将秩较小的树合并到秩较大的树上
        } else {
            ds->parent[yRoot] = xRoot;  // 秩相同，任意合并，但需要增加秩
            ds->rank[xRoot]++;
        }
    }
}

// 释放不相交集合
void freeDisjointSet(DisjointSet *ds) {
    free(ds->parent);
    free(ds->rank);
    free(ds);
}

// 示例：处理一系列操作
int main() {
    int n, m;
    printf("请输入元素个数和操作个数：");
    scanf("%d %d", &n, &m);

    DisjointSet *ds = createDisjointSet(n);

    for (int i = 0; i < m; i++) {
        int op, x, y;
        printf("请输入操作类型(0: 查找, 1: 合并) 和涉及的元素：");
        scanf("%d %d %d", &op, &x, &y);

        if (op == 0) {  // 查找操作
            int rootX = find(ds, x);
            int rootY = find(ds, y);
            if (rootX == rootY) {
                printf("元素 %d 和 %d 在同一个集合中\n", x, y);
            } else {
                printf("元素 %d 和 %d 不在同一个集合中\n", x, y);
            }
        } else if (op == 1) {  // 合并操作
            unionSets(ds, x, y);
            printf("元素 %d 和 %d 已合并\n", x, y);
        }
    }

    freeDisjointSet(ds);
    return 0;
}
代码说明

  1. 创建不相交集合：

    • createDisjointSet 函数初始化一个不相交集合，每个元素的初始父节点是自己，秩为0。

  2. 查找操作：

    • find 函数使用路径压缩技术，将查找路径上的所有节点直接指向根节点，提高后续查找效率。

  3. 合并操作：

    • unionSets 函数使用按秩合并技术，将秩较小的树合并到秩较大的树上，保持树的高度较低，提高查找效率。如果两个树的秩相同，则任意合并，并增加合并后的树的秩。

  4. 释放内存：

    • freeDisjointSet 函数释放不相交集合占用的内存。

总结

不相交集合 ADT 是一种非常有用的数据结构，通过路径压缩和按秩合并，可以高效地处理集合的合并和查找操作。这种数据结构在图算法、网络流问题和并查集问题中非常有用。

不相交集合的问题与解决方案

问题 1：Kruskal 最小生成树算法

解决方案：使用不相交集合 ADT 来实现 Kruskal 最小生成树算法。具体步骤如下：

  1. 对所有边按权重进行排序。

  2. 初始化不相交集合。

  3. 遍历排序后的边，如果边的两个顶点不在同一个集合中，则将边加入最小生成树，并合并这两个集合。

代码示例
typedef struct Edge {
    int u, v, weight;
} Edge;

// 比较函数，用于排序
int compareEdges(const void *a, const void *b) {
    return ((Edge*)a)->weight - ((Edge*)b)->weight;
}

// Kruskal 最小生成树算法
void kruskalMST(Edge edges[], int n, int m) {
    qsort(edges, m, sizeof(Edge), compareEdges);
    DisjointSet *ds = createDisjointSet(n);
    int mstWeight = 0;
    for (int i = 0; i < m; i++) {
        int u = edges[i].u;
        int v = edges[i].v;
        int weight = edges[i].weight;
        if (find(ds, u) != find(ds, v)) {
            unionSets(ds, u, v);
            mstWeight += weight;
            printf("Edge %d-%d with weight %d included in MST\n", u, v, weight);
        }
    }
    printf("Total weight of MST: %d\n", mstWeight);
    freeDisjointSet(ds);
}

问题 2：网络流问题

解决方案：使用不相交集合 ADT 来管理网络中的流量。具体步骤如下：

  1. 初始化不相交集合。

  2. 遍历网络中的所有边，如果边的两个顶点不在同一个集合中，则将边加入网络流，并合并这两个集合。

代码示例
// 网络流问题的代码与 Kruskal 最小生成树算法类似，只是在处理边时需要考虑流量

问题 3：并查集问题

解决方案：使用不相交集合 ADT 来处理并查集问题。具体步骤如下：

  1. 初始化不相交集合。

  2. 遍历所有操作，如果是查找操作，则调用 find 函数；如果是合并操作，则调用 unionSets 函数。

代码示例
// 并查集问题的代码与 Kruskal 最小生成树算法类似，只是在处理操作时需要根据操作类型调用不同的函数

#include <stdio.h>
#include <stdlib.h>

// 定义并查集结构体
typedef struct {
    int *parent;  // 父节点数组
    int *rank;    // 秩数组，用于优化合并操作
    int size;     // 集合的大小
} DisjointSet;

// 初始化并查集
DisjointSet* makeSet(int size) {
    DisjointSet *set = (DisjointSet*)malloc(sizeof(DisjointSet));
    set->parent = (int*)malloc(size * sizeof(int));
    set->rank = (int*)malloc(size * sizeof(int));
    set->size = size;

    for (int i = 0; i < size; i++) {
        set->parent[i] = i;  // 每个元素的初始父节点是自己
        set->rank[i] = 0;    // 初始秩为0
    }

    return set;
}

// 查找操作，路径压缩
int find(DisjointSet *set, int x) {
    if (set->parent[x] != x) {
        set->parent[x] = find(set, set->parent[x]);  // 路径压缩
    }
    return set->parent[x];
}

// 合并操作，按秩合并
void unionSets(DisjointSet *set, int x, int y) {
    int rootX = find(set, x);
    int rootY = find(set, y);

    if (rootX != rootY) {
        if (set->rank[rootX] > set->rank[rootY]) {
            set->parent[rootY] = rootX;
        } else if (set->rank[rootX] < set->rank[rootY]) {
            set->parent[rootX] = rootY;
        } else {
            set->parent[rootY] = rootX;
            set->rank[rootX]++;
        }
    }
}

// 释放并查集内存
void freeSet(DisjointSet *set) {
    free(set->parent);
    free(set->rank);
    free(set);
}

// 示例：处理一系列操作
int main() {
    int n, m;
    printf("请输入元素个数和操作个数：");
    scanf("%d %d", &n, &m);

    DisjointSet *set = makeSet(n);

    for (int i = 0; i < m; i++) {
        int op, x, y;
        printf("请输入操作类型(0: 查找, 1: 合并) 和涉及的元素：");
        scanf("%d %d %d", &op, &x, &y);

        if (op == 0) {  // 查找操作
            int rootX = find(set, x);
            int rootY = find(set, y);
            if (rootX == rootY) {
                printf("元素 %d 和 %d 在同一个集合中\n", x, y);
            } else {
                printf("元素 %d 和 %d 不在同一个集合中\n", x, y);
            }
        } else if (op == 1) {  // 合并操作
            unionSets(set, x, y);
            printf("元素 %d 和 %d 已合并\n", x, y);
        }
    }

    freeSet(set);
    return 0;
}
代码说明

  1. 初始化并查集：

    • makeSet 函数初始化一个并查集，每个元素的初始父节点是自己，秩为0。

  2. 查找操作：

    • find 函数使用路径压缩技术，将查找路径上的所有节点直接指向根节点，提高后续查找效率。

  3. 合并操作：

    • unionSets 函数使用按秩合并技术，将秩较小的树合并到秩较大的树上，保持树的高度较低，提高查找效率。

  4. 释放内存：

    • freeSet 函数释放并查集占用的内存。

  5. 示例：

    • main 函数中，用户输入元素个数和操作个数，然后输入一系列操作（查找或合并），并输出操作结果。

通过以上对不相交集合 ADT 的深入探讨，我们可以看到这种数据结构在计算机科学的各个领域都有着广泛的应用。无论是在算法设计、数据存储还是网络通信中，不相交集合 ADT 都扮演着不可或缺的角色。希望这篇文章能帮助你更好地理解和应用这种强大的数据结构。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值