【数据结构】最小生成树

最小生成树（Minimum Spanning Tree, MST）是图论中的一个重要概念，用于解决连接图中所有顶点且边权值之和最小的问题。在最小生成树中，任意两个顶点之间都有且仅有一条路径。本文将详细介绍两种常用的最小生成树算法——Prim算法和Kruskal算法的原理，并提供C语言代码示例，演示它们的实现方式及应用场景。

一、Prim算法

Prim算法是一种贪心算法，从一个顶点出发，逐步扩展树的规模，直到覆盖所有顶点为止。它的基本思想是，每次选择一个已经在树中的顶点作为起始点，然后找到与树中顶点相邻且权值最小的边，将其加入树中，直到所有顶点都被包含在树中为止。

理论知识：

1. 初始状态： 将任意一个顶点作为起始点，加入到最小生成树中。
2. 迭代过程： 每次从已经在树中的顶点出发，找到与之相邻且权值最小的边，将其加入到最小生成树中。
3. 终止条件： 直到所有顶点都被包含在树中为止。

C语言实现：

下面是用C语言实现Prim算法的示例代码：

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

#define V 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("最小生成树的边：\n");
    for (int i = 1; i < V; i++) {
        printf("%d - %d\n", parent[i], i);
    }
}

void primMST(int graph[V][V]) {
    int parent[V];
    int key[V];
    int mstSet[V];

    for (int i = 0; i < V; i++) {
        key[i] = INT_MAX;
        mstSet[i] = 0;
    }

    key[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;
}

二、Kruskal算法

Kruskal算法也是一种贪心算法，与Prim算法不同的是，它是基于边来构建最小生成树的。它的基本思想是，将所有边按照权值从小到大进行排序，然后依次选择权值最小的边，如果该边不会形成环路，则将其加入最小生成树中，直到生成树中包含了所有顶点为止。

理论知识：

1. 初始化： 将所有边按权值排序。
2. 迭代过程： 依次选择权值最小的边，如果该边不会形成环路，则将其加入最小生成树中。
3. 终止条件： 直到生成树中包含了所有顶点为止。

C语言实现：

下面是用C语言实现Kruskal算法的示例代码：

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

#define V 5 // 图中顶点数

typedef struct {
    int src, dest, weight;
} Edge;

typedef struct {
    int parent;
    int rank;
} Subset;

int find(Subset subsets[], int i) {
    if (subsets[i].parent != i) {
        subsets[i].parent = find(subsets, subsets[i].parent);
    }
    return subsets[i].parent;
}

void Union(Subset subsets[], int x, int y) {
    int xroot = find(subsets, x);
    int yroot = find(subsets, y);

    if (subsets[xroot].rank < subsets[yroot].rank) {
        subsets[xroot].parent = yroot;
    } else if (subsets[xroot].rank > subsets[yroot].rank) {
        subsets[yroot].parent = xroot;
    } else {
        subsets[yroot].parent = xroot;
        subsets[xroot].rank++;
    }
}

int compare(const void* a, const void* b) {
    Edge* a1 = (Edge*)a;
    Edge* b1 = (Edge*)b;
    return a1->weight - b1->weight;
}

void kruskalMST(Edge edges[]) {
    Edge result[V];
    int e = 0;
    int i = 0;

    qsort(edges, V, sizeof(Edge), compare);

    Subset subsets[V];

    for (int v = 0; v < V; v++) {
        subsets[v].parent = v;
        subsets[v].rank = 0;
    }

    while (e < V

 - 1 && i < V) {
        Edge next_edge = edges[i++];

        int x = find(subsets, next_edge.src);
        int y = find(subsets, next_edge.dest);

        if (x != y) {
            result[e++] = next_edge;
            Union(subsets, x, y);
        }
    }

    printf("最小生成树的边：\n");
    for (i = 0; i < e; i++) {
        printf("%d - %d\n", result[i].src, result[i].dest);
    }
}

int main() {
    Edge edges[] = {
        {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;
}

通过以上的理论介绍和C语言代码示例，我们深入了解了Prim算法和Kruskal算法这两种常用的最小生成树算法，并学习了它们的实现方式及应用场景。在实际应用中，根据具体情况选择合适的算法，将有助于解决各种图相关的问题。