Kruskal算法及其在最小生成树中的应用

引言

  最小生成树（Minimum Spanning Tree，简称MST）是图论中的一个经典问题，广泛应用于网络设计、电路布线、城市规划等领域。Kruskal算法作为一种常用的构建最小生成树的方法，具有简单高效的特点。本文将介绍Kruskal算法的原理、实现以及其在最小生成树问题中的应用。

Kruskal算法的原理

  Kruskal算法是一种贪心算法，其基本思想是按照边的权重从小到大选择边，逐步构建最小生成树。算法的核心是通过判断边的两个端点是否属于同一个连通分量来避免形成环路，这一判断通过并查集数据结构实现。

代码实现

  在代码实现方面，我们需要定义边的结构体和并查集的结构体。边的结构体包含起点、终点和权重；并查集的结构体包含一个父节点数组和一个秩数组，用于记录节点的父节点和秩信息。此外，还需要实现边的比较函数，用于按照权重对边进行排序。

Kruskal算法的实现分为以下几个步骤：

1.对所有边按照权重进行排序。
2.创建一个并查集对象，并初始化每个节点的父节点为自身，秩为0。
3.初始化一个空的最小生成树数组，记录已选取的边数和当前边的索引。
4.遍历排序后的边，选择边的起点和终点的根节点。
5.如果起点和终点的根节点不同，说明选择当前边不会形成环路，将该边加入最小生成树数组，并6.将起点和终点合并。
7.重复步骤4和步骤5，直到最小生成树数组中的边数等于节点数减1或者遍历完所有边。
8.输出最小生成树数组。

边的结构体

struct Edge {   // 边的结构体
    int src;    //src表示边的起点
    int dest;   //dest表示边的终点
    int  weight;//weight表示边的权重
};

并查集的实现

struct UnionFind {      // 并查集的结构体
    vector<int> parent; //节点的父节点
    vector<int> rank;   //节点所属树的高度

    UnionFind(int n) {  //初始化并查集
        parent.resize(n);
        rank.resize(n, 0);
        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) {
            if (rank[rootX] < rank[rootY]) {
                parent[rootX] = rootY;
            }
            else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            }
            else {
                parent[rootY] = rootX;
                rank[rootX]++;
            }
        }
    }
};
 

算法实现

bool compareEdges(const Edge& a, const Edge& b) { // 按照边的权重进行排序的比较函数
    return a.weight < b.weight;
}

// Kruskal算法实现
void kruskalMST(vector<Edge>& edges, int numVertices) {
    // 按照边的权重进行排序
    sort(edges.begin(), edges.end(), compareEdges);

    // 创建并查集
    UnionFind uf(numVertices);

    vector<Edge> minimumSpanningTree;
    int numEdges = 0;
    int index = 0;

    // 选择边
    while (numEdges < numVertices - 1 && index < edges.size()) {
        Edge currentEdge = edges[index++];
        int srcRoot = uf.find(currentEdge.src);
        int destRoot = uf.find(currentEdge.dest);

        // 判断是否形成环路
        if (srcRoot != destRoot) {
            minimumSpanningTree.push_back(currentEdge);
            uf.unite(srcRoot, destRoot);
            numEdges++;
        }
    }

    // 输出最小生成树
    cout << "最小生成树:" << endl;
    for (const auto& edge : minimumSpanningTree) {
        cout << edge.src << " -- " << edge.dest << " : " << edge.weight << endl;
    }
}

源代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Edge {   // 边的结构体
    int src;    //src表示边的起点
    int dest;   //dest表示边的终点
    int  weight;//weight表示边的权重
};

struct UnionFind {      // 并查集的结构体
    vector<int> parent; //节点的父节点
    vector<int> rank;   //节点所属树的高度

    UnionFind(int n) {  //初始化并查集
        parent.resize(n);
        rank.resize(n, 0);
        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) {
            if (rank[rootX] < rank[rootY]) {
                parent[rootX] = rootY;
            }
            else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            }
            else {
                parent[rootY] = rootX;
                rank[rootX]++;
            }
        }
    }
};

bool compareEdges(const Edge& a, const Edge& b) { // 按照边的权重进行排序的比较函数
    return a.weight < b.weight;
}

// Kruskal算法实现
void kruskalMST(vector<Edge>& edges, int numVertices) {
    // 按照边的权重进行排序
    sort(edges.begin(), edges.end(), compareEdges);

    // 创建并查集
    UnionFind uf(numVertices);

    vector<Edge> minimumSpanningTree;
    int numEdges = 0;
    int index = 0;

    // 选择边
    while (numEdges < numVertices - 1 && index < edges.size()) {
        Edge currentEdge = edges[index++];
        int srcRoot = uf.find(currentEdge.src);
        int destRoot = uf.find(currentEdge.dest);

        // 判断是否形成环路
        if (srcRoot != destRoot) {
            minimumSpanningTree.push_back(currentEdge);
            uf.unite(srcRoot, destRoot);
            numEdges++;
        }
    }

    // 输出最小生成树
    cout << "最小生成树:" << endl;
    for (const auto& edge : minimumSpanningTree) {
        cout << edge.src << " -- " << edge.dest << " : " << edge.weight << endl;
    }
}

int main() {
    int numVertices = 6;
    vector<Edge> edges = {
        {0, 1, 4},    // 边的起点、终点和权重
        {0, 2, 3},
        {1, 2, 1},
        {1, 3, 2},
        {2, 3, 4},
        {3, 4, 2},
        {4, 5, 6}
    };

    kruskalMST(edges, numVertices);

    return 0;
}

与Prim算法的比较

Kruskal算法和Prim算法都是常用的用于解决最小生成树（Minimum Spanning Tree，MST）问题的算法，但它们的实现和思路有所不同。

1. Kruskal算法：
   - Kruskal算法采用贪心策略，通过不断选择边的方式构建最小生成树。
   - 首先，将图中的所有边按照权重从小到大进行排序。
   - 然后，依次考虑排序后的边，如果该边连接的两个节点不在同一个连通分量中，则将该边加入最小生成树中。
   - 最终，当最小生成树中的边数达到节点数减一时，算法结束。
   - Kruskal算法使用并查集数据结构来维护连通分量，判断两个节点是否在同一个连通分量中。

2. Prim算法：
   - Prim算法也采用贪心策略，通过逐步扩展生成树的方式构建最小生成树。
   - 首先，选择一个起始节点，将其加入最小生成树中。
   - 然后，从已经加入最小生成树的节点中选择一条边，该边连接已经加入最小生成树的节点和未加入最小生成树的节点，并且权重最小。
   - 将选择的边加入最小生成树，并将新加入的节点标记为已访问。
   - 重复上述步骤，直到最小生成树包含所有的节点。
   - Prim算法使用优先队列（最小堆）来选择权重最小的边。

比较：
- 时间复杂度：Kruskal算法和Prim算法的时间复杂度都与边的数量E和节点的数量V有关。
  - Kruskal算法的时间复杂度为O(ElogE)，因为需要对所有边进行排序。
  - Prim算法的时间复杂度为O(ElogV)，因为需要对边进行优先队列的维护。
- 空间复杂度：Kruskal算法和Prim算法的空间复杂度都与边的数量E和节点的数量V有关。
  - Kruskal算法需要使用并查集数据结构来维护连通分量，所需的额外空间为O(V)。
  - Prim算法需要使用优先队列来选择边，所需的额外空间为O(E)。
- 适用场景：两种算法适用于不同类型的图。
  - Kruskal算法适用于稀疏图，即边的数量相对较小的情况。
  - Prim算法适用于稠密图，即边的数量相对较大的情况。
- 边权重的处理：Kruskal算法和Prim算法对于边权重的处理方式略有不同。
  - Kruskal算法通过排序边的权重，并按照权重从小到大的顺序选择边。
  - Prim算法通过优先队列选择权重最小的边。

综上所述，Kruskal算法和Prim算法都是解决最小生成树问题的有效算法，选择哪种算法取决于图的特性和具体的应用场景。