Kruskal算法详解-CSDN博客

本文链接：https://blog.csdn.net/qq_41256535/article/details/139649863

一、引言

在图论中，最小生成树问题是一个经典的问题。给定一个无向加权图，最小生成树就是其中边权值之和最小的生成树。Kruskal算法是解决这个问题的一种有效方法。它基于贪心策略，每次从未选择的边中选择一条权值最小的边，如果这条边加入后不会形成环，则将其加入最小生成树中。本文将对Kruskal算法进行详细的解释，并附上C++代码实现。

二、算法原理

Kruskal算法的核心思想是贪心加并查集。算法的执行过程可以大致分为以下几步：

初始化：将所有边按照权值从小到大进行排序。
并查集初始化：将图中的每个顶点都视为一个独立的集合。
遍历排序后的边：对于排序后的每一条边，执行以下操作：
- 判断这条边的两个顶点是否属于同一个集合（即是否已经连通）。
- 如果两个顶点属于不同的集合（即未连通），则将这条边加入最小生成树中，并将两个集合合并。
- 如果两个顶点属于同一个集合（即已连通），则跳过这条边，继续下一条边的判断。
结束条件：当已经选择了n-1条边（n为顶点数）时，算法结束，此时得到的就是最小生成树。

需要注意的是，为了判断两个顶点是否属于同一个集合，我们使用了并查集数据结构。并查集可以高效地实现集合的合并和查询操作。

三、算法实现

下面是一个使用C++实现的Kruskal算法示例代码：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 并查集类
class UnionFind {
private:
    vector<int> parent;

public:
    UnionFind(int n) : parent(n) {
        for (int i = 0; i < n; ++i) {
            parent[i] = i;
        }
    }

    // 查找根节点
    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]); // 路径压缩
        }
        return parent[x];
    }

    // 合并两个集合
    void unite(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX != rootY) {
            parent[rootX] = rootY;
        }
    }

    // 判断两个节点是否属于同一个集合
    bool isConnected(int x, int y) {
        return find(x) == find(y);
    }
};

// 边结构体
struct Edge {
    int u, v, w; // u, v为边的两个顶点，w为边的权值
    bool operator<(const Edge& other) const {
        return w < other.w; // 按照权值从小到大排序
    }
};

// Kruskal算法实现
vector<Edge> kruskal(vector<Edge>& edges, int n) {
    vector<Edge> result;
    UnionFind uf(n); // 初始化并查集

    sort(edges.begin(), edges.end()); // 对边进行排序

    for (const auto& edge : edges) {
        if (!uf.isConnected(edge.u, edge.v)) { // 如果两个顶点未连通
            result.push_back(edge); // 将边加入最小生成树
            uf.unite(edge.u, edge.v); // 合并两个集合

            // 如果已经选择了n-1条边，则结束算法
            if (result.size() == n - 1) {
                break;
            }
        }
    }

    return result;
}

int main() {
    // 示例输入：5个顶点，7条边
    vector<Edge> edges = {{0, 1, 10}, {0, 2, 6}, {0, 3, 5}, {1, 3, 15}, {2, 3, 4}, {3, 4, 14}, {2, 4, 2}};
    int n = 5; // 顶点数

    // 调用Kruskal算法
    vector<Edge> mst = kruskal(edges, n);

    // 输出最小生成树中的边
cout << "The edges in the minimum spanning tree are:" << endl;
for (const auto& edge : mst) {
    cout << "(" << edge.u << ", " << edge.v << ") with weight " << edge.w << endl;
}

// 如果需要，可以进一步验证最小生成树的正确性，比如检查是否包含了所有顶点且没有环
// 这里省略验证步骤，因为主要目的是展示Kruskal算法的实现

return 0;
}

四、算法分析

时间复杂度：Kruskal算法的时间复杂度主要由排序和并查集操作决定。排序的时间复杂度为O(m log m)，其中m为边的数量。并查集操作（包括查找和合并）的时间复杂度在平均情况下为O(α(n))，其中n为顶点的数量，α为Ackermann函数的反函数，其增长非常缓慢，可以视为常数。因此，Kruskal算法的总时间复杂度为O(m log m)。
空间复杂度：Kruskal算法的空间复杂度主要取决于存储边和并查集所需的空间。在最坏情况下，需要存储所有的边，因此空间复杂度为O(m)，其中m为边的数量。并查集的空间复杂度为O(n)，其中n为顶点的数量。因此，总空间复杂度为O(m + n)，但由于通常边的数量远大于顶点的数量，所以通常简化为O(m)。

五、总结

Kruskal算法是一种基于贪心策略和并查集的数据结构来解决最小生成树问题的有效算法。它通过不断选择权值最小的边并检查是否形成环来构建最小生成树。算法的时间复杂度和空间复杂度都较为优秀，因此在实际应用中得到了广泛的应用。通过本文的详解和C++代码实现，读者可以更加深入地理解Kruskal算法的原理和实现过程。