Kruskal算法实现最小生成树 先构造一个只含 n 个顶点的子图 SG，然后从权值最小的边开始，若它的添加不使SG 中产生回路，则在 SG 上加上这条边，如此重复，直至加上 n-1 条边为止。 输入图的相关信息，使用Kruskal算法，生成最小生成树。 输入说明： 先输入图中顶点个数和边的数目，空格间隔； 然后输入每个顶点的数据； 最后依次输入每条边的起始和终止顶点的位序及边上的权值，格式为：顶点1位序 顶点2位序 权值。 输出说明： 按生成次序依次输出最小生成树中的各边的起始顶点位序和终止顶点位序，用英文逗号间隔，一对圆括号括起来，且较小的顶点在前。c++实现，给出完整代码，要求尽量简单

以下是使用C++语言实现Kruskal算法生成最小生成树的完整代码，其中使用了并查集（Union Find）数据结构来判断是否出现回路。

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

using namespace std;

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

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

    Graph(int V, int E) {
        this->V = V;
        this->E = E;
    }

    void addEdge(int u, int v, int w) {
        edges.push_back({u, v, w});
    }

    int find(int parent[], int i) {
        if (parent[i] == -1) {
            return i;
        }
        return find(parent, parent[i]);
    }

    void Union(int parent[], int x, int y) {
        parent[x] = y;
    }

    void kruskalMST() {
        vector<Edge> result;

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

        int *parent = new int[V];
        memset(parent, -1, sizeof(int) * V);

        int count = 0;
        for (Edge edge : edges) {
            int x = find(parent, edge.src);
            int y = find(parent, edge.dest);

            if (x != y) {
                result.push_back(edge);
                Union(parent, x, y);
                count++;
            }

            if (count == V - 1) {
                break;
            }
        }

        for (Edge edge : result) {
            cout << "(" << min(edge.src, edge.dest) << "," << max(edge.src, edge.dest) << ") ";
        }
    }
};

int main() {
    int V, E;
    cin >> V >> E;

    Graph graph(V, E);

    for (int i = 0; i < V; i++) {
        int data;
        cin >> data;
    }

    for (int i = 0; i < E; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        graph.addEdge(u, v, w);
    }

    graph.kruskalMST();

    return 0;
}

其中，kruskalMST()函数实现了Kruskal算法的核心逻辑，使用并查集来判断是否出现回路，并将加入最小生成树的边存入result数组中，最终输出每条边的起始顶点位序和终止顶点位序。