最小生成树（Minimum Spanning Tree，MST）

最新推荐文章于 2025-03-13 12:16:45 发布

请向我看齐

最新推荐文章于 2025-03-13 12:16:45 发布

阅读量418

点赞数 4

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/qq_40844444/article/details/143964906

版权

算法专栏收录该内容

121 篇文章

订阅专栏

以下是关于最小生成树算法的详细介绍：

概念

最小生成树（Minimum Spanning Tree，MST）是对于一个带权无向连通图而言，包含图中所有顶点的一个极小连通子图，且它的所有边的权值之和在所有这样的连通子图中是最小的。简单来说，就是用最少的边把图中所有顶点连接起来，并且这些边的总权重最小。

原理

基于贪心算法的思想，每次选择一条权值最小且不会形成环的边加入到生成树的边集合中，直到生成树包含图中的所有顶点为止。

分类及步骤

常见的最小生成树算法主要有以下两种：

1. Prim 算法

• 步骤：

• 初始化：从任意一个顶点开始，标记该顶点已访问，设置一个最小堆（优先队列）来存储候选边（边的权重以及连接的顶点）。

• 循环选取： 每次从最小堆中取出权重最小的边，该边连接已访问顶点和未访问顶点，如果取出的边不会形成环（通过判断未访问顶点是否已在生成树中），则将这条边加入到最小生成树的边集合中，并标记对应的未访问顶点为已访问，同时将与该新加入顶点相连的所有未访问顶点对应的边加入到最小堆中。

• 终止条件： 当所有顶点都被访问，即最小生成树包含了图中所有顶点时，算法结束。

• C 代码实现如下：

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

#define V 5  // 定义顶点个数，这里假设图有5个顶点，可根据实际修改

// 找到未访问顶点中距离最小生成树最近的顶点
int minKey(int key[], int mstSet[]) {
    int min = INT_MAX, min_index;
    for (int v = 0; v < V; v++) {
        if (mstSet[v] == 0 && key[v] < min) {  // 如果顶点未访问且当前距离更小
            min = key[v];
            min_index = v;
        }
    }
    return min_index;
}

// 打印最小生成树的边和权重
void printMST(int parent[], int graph[V][V]) {
    printf("Edge \tWeight\n");
    for (int i = 1; i < V; i++)
        printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);
}

// Prim 算法实现
void primMST(int graph[V][V]) {
    int parent[V];  // 存储最小生成树中每个顶点的父节点
    int key[V];     // 存储各个顶点到最小生成树的最小距离（权重）
    int mstSet[V];  // 标记顶点是否已加入最小生成树，0表示未加入，1表示已加入

    // 初始化所有距离为最大值，标记都为未加入
    for (int i = 0; i < V; i++) {
        key[i] = INT_MAX;
        mstSet[i] = 0;
    }

    key[0] = 0;  // 从第一个顶点开始，距离设为0
    parent[0] = -1;  // 第一个顶点没有父节点

    for (int count = 0; count < V - 1; count++) {
        int u = minKey(key, mstSet);  // 找到距离最小生成树最近的未访问顶点
        mstSet[u] = 1;  // 将该顶点标记为已加入最小生成树

        for (int v = 0; v < V; v++) {
            if (graph[u][v] && mstSet[v] == 0 && graph[u][v] < key[v]) {  // 如果存在边，顶点未加入且距离更小
                parent[v] = u;
                key[v] = graph[u][v];
            }
        }
    }

    printMST(parent, graph);
}

int main() {
    int graph[V][V] = {
        {0, 2, 0, 6, 0},
        {2, 0, 3, 8, 5},
        {0, 3, 0, 0, 7},
        {6, 8, 0, 0, 9},
        {0, 5, 7, 9, 0}
    };

    primMST(graph);

    return 0;
}

• 时间复杂度： 使用二叉堆实现的优先队列时，时间复杂度为 O(V^2)（对于稠密图），使用斐波那契堆实现优先队列时，时间复杂度可以优化到 O(E + V \log V)（E 是边的数量，V 是顶点数量）。

• 空间复杂度： 主要取决于存储图、顶点距离、标记数组等，为 O(V^2)。

2. Kruskal 算法

• 步骤：

• 初始化： 将图中所有边按照权值从小到大进行排序，初始化一个空的最小生成树边集合，每个顶点各自构成一个连通分量（可以用并查集来维护连通性）。

• 循环选取： 按排序后的顺序依次选取边，如果选取的这条边连接的两个顶点属于不同的连通分量（通过并查集判断），则将这条边加入到最小生成树的边集合中，并合并这两个连通分量（在并查集中进行合并操作）。

• 终止条件： 当选取的边数量为顶点数量减 1 时，算法结束，此时得到了最小生成树。

• C 代码实现如下：

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

#define V 5  // 定义顶点个数，可按需修改
#define E 7  // 定义边的数量，需根据实际图的边数确定

// 边的结构体，存储边的两个顶点和权重
typedef struct Edge {
    int src, dest, weight;
} Edge;

// 并查集相关函数
int find(int parent[], int i) {
    if (parent[i] == i)
        return i;
    return find(parent, parent[i]);
}

void unionSet(int parent[], int x, int y) {
    int xset = find(parent, x);
    int yset = find(parent, y);
    if (xset!= yset)
        parent[xset] = yset;
}

// 比较函数，用于给边排序（按照权重从小到大）
int compare(const void* a, const void* b) {
    Edge* e1 = (Edge*)a;
    Edge* e2 = (Edge*)b;
    return e1->weight - e2->weight;
}

// Kruskal 算法实现
void kruskalMST(Edge edges[]) {
    Edge result[V - 1];  // 存储最小生成树的边
    int e = 0;  // 已添加到最小生成树的边的数量
    int i = 0;  // 遍历排序后所有边的索引
    int parent[V];

    // 初始化并查集，每个顶点的父节点是自己
    for (int v = 0; v < V; v++)
        parent[v] = v;

    while (e < V - 1 && i < E) {
        Edge nextEdge = edges[i++];
        int x = find(parent, nextEdge.src);
        int y = find(parent, nextEdge.dest);

        if (x!= y) {  // 如果两个顶点属于不同连通分量
            e++;
            result[e - 1] = nextEdge;
            unionSet(parent, x, y);
        }
    }

    printf("Edge \tWeight\n");
    for (int j = 0; j < e; j++)
        printf("%d - %d \t%d \n", result[j].src, result[j].dest, result[j].weight);
}

int main() {
    Edge edges[E] = {
        {0, 1, 2},
        {0, 3, 6},
        {1, 2, 3},
        {1, 3, 8},
        {1, 4, 5},
        {2, 4, 7},
        {3, 4, 9}
    };

    kruskalMST(edges);

    return 0;
}