数据结构-最小生成树的算法与实现

最新推荐文章于 2024-09-23 08:00:00 发布

轩Scott

最新推荐文章于 2024-09-23 08:00:00 发布

阅读量1.2k

点赞数 1

文章标签：算法

本文链接：https://blog.csdn.net/m0_61789994/article/details/130773672

版权

本文介绍了最小生成树的概念，它是图论中的一个重要数据结构，用于寻找连通无向图的最低成本树。文章详细讲解了Prim和Kruskal算法，并提供了C++实现示例，展示了这两种算法如何找到最小生成树。此外，还探讨了最小生成树在网络设计、物流和电力传输等领域的应用。

摘要由CSDN通过智能技术生成

1. 引言

数据结构是计算机科学中的重要概念之一，它用于组织和存储数据，使得数据的操作更加高效。其中，最小生成树是一种常见的数据结构，它在图论中扮演着重要的角色。本篇博客将深入介绍最小生成树的定义、常见算法和C++实现，帮助读者更好地理解和应用最小生成树。

2. 最小生成树的定义

最小生成树是指在一个连通无向图中，选择一些边构成树，使得这些边的权值之和最小，并且这些边连接了图中的所有节点。最小生成树的主要特点是包含图中的所有节点且没有形成环路。

3. 常见的最小生成树算法

在实际应用中，有多种算法可以用于构建最小生成树。下面介绍两种常见的算法：Prim算法和Kruskal算法。

3.1 Prim算法

Prim算法是一种贪心算法，它从一个节点开始，逐步选择与当前生成树相连的最小权值边，并加入到生成树中。具体步骤如下：
1. 初始化一个空的生成树和一个空的候选边集合。
2. 从任意节点开始，将该节点加入生成树。
3. 将与该节点相连的边加入候选边集合。
4. 从候选边集合中选择权值最小的边，并将其加入生成树。
5. 重复步骤3和步骤4，直到生成树包含了所有节点。

3.2 Kruskal算法

Kruskal算法也是一种贪心算法，它通过不断选择权值最小的边，并加入生成树中，直到生成树包含了所有节点。具体步骤如下：
1. 初始化一个空的生成树和一个空的边集合。
2. 将所有边按照权值从小到大排序。
3. 依次选择权值最小的边，如果该边不会形成环路，则将其加入生成树。
4. 重复步骤3，直

到生成树包含了所有节点。

4. C++实现最小生成树算法

4.1 Prim算法的C++实现

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct Edge {
    int u, v, weight;
    Edge(int u, int v, int weight) : u(u), v(v), weight(weight) {}
};

class Graph {
private:
    int V;
    vector<vector<pair<int, int>>> adj;

public:
    Graph(int V) : V(V) {
        adj.resize(V);
    }

    void addEdge(int u, int v, int weight) {
        adj[u].push_back(make_pair(v, weight));
        adj[v].push_back(make_pair(u, weight));
    }

    int primMST() {
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
        vector<bool> visited(V, false);
        int minCost = 0;

        pq.push(make_pair(0, 0));

        while (!pq.empty()) {
            int u = pq.top().second;
            int weight = pq.top().first;
            pq.pop();

            if (visited[u])
                continue;

            visited[u] = true;
            minCost += weight;

            for (auto neighbor : adj[u]) {
                int v = neighbor.first;
                int w = neighbor.second;
                if (!visited[v])
                    pq.push(make_pair(w, v));
            }
        }

        return minCost;
    }
};

int main() {
    int V, E;
    cout << "Enter the number of vertices: ";
    cin >> V;
    cout << "Enter the number of edges: ";
    cin >> E;

    Graph g(V);

    cout << "Enter the edges in the format (u, v, weight):" << endl;
    for (int i = 0; i < E; i++) {
        int u, v, weight;
        cin >> u >> v >> weight;
        g.addEdge(u, v, weight);
    }

    int minCost = g.primMST();
    cout << "Minimum cost of the MST: " << minCost << endl;

    return 0;
}

4.2 Kruskal算法的C++实现

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

using namespace std;

struct Edge {
    int u, v, weight;
    Edge(int u, int v, int weight) : u(u), v(v), weight(weight) {}
};

class DisjointSet {
private:
    vector<int> parent, rank;

public:
    DisjointSet(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 xRoot = find(x);
        int yRoot = find(y);

        if (rank[xRoot] < rank[yRoot])
            parent[xRoot] = yRoot;
        else if (rank[xRoot] > rank[yRoot])
            parent[yRoot] = xRoot;
        else {
            parent[yRoot] = xRoot;
            rank[xRoot]++;
        }
    }
};

class Graph {
private:
    int V, E;
    vector<Edge> edges;

public:
    Graph(int V, int E) : V(V), E(E) {
       

 edges.resize(E);
    }

    void addEdge(int u, int v, int weight, int index) {
        edges[index] = Edge(u, v, weight);
    }

    int kruskalMST() {
        sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {
            return a.weight < b.weight;
        });

        DisjointSet ds(V);
        int minCost = 0;

        for (int i = 0; i < E; i++) {
            int u = edges[i].u;
            int v = edges[i].v;
            int weight = edges[i].weight;

            int uRoot = ds.find(u);
            int vRoot = ds.find(v);

            if (uRoot != vRoot) {
                minCost += weight;
                ds.unite(uRoot, vRoot);
            }
        }

        return minCost;
    }
};

int main() {
    int V, E;
    cout << "Enter the number of vertices: ";
    cin >> V;
    cout << "Enter the number of edges: ";
    cin >> E;

    Graph g(V, E);

    cout << "Enter the edges in the format (u, v, weight):" << endl;
    for (int i = 0; i < E; i++) {
        int u, v, weight;
        cin >> u >> v >> weight;
        g.addEdge(u, v, weight, i);
    }

    int minCost = g.kruskalMST();
    cout << "Minimum cost of the MST: " << minCost << endl;

    return 0;
}

5. 最小生成树的应用领域

最小生成树在许多领域有广泛的应用，包括：

- 网络设计：最小生成树可用于设计通信网络中的最优链路，以减少成本和提高传输效率。
- 物流和运输：最小生成树可用于确定最优路径和运输线路，以降低物流成本。
- 电力传输：最小生成树可用于确定输电网络中的最优电缆布局，以提高能源传输效率。
- 近似算法：最小生成树可以作为解决其他优化问题的近似算法的基础。