克鲁斯卡尔（kruskal）算法——用于求出一个连通图中的最小生成树

C++实现

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <unordered_map>

using namespace std;

// 定义边的结构，包含源节点、目标节点和权重
struct Edge {
    string src;
    string dest;
    int weight;
    
    // 重载比较运算符，用于边的排序
    bool operator<(const Edge& other) const {
        return weight < other.weight;
    }
};

// 并查集（Union-Find）数据结构
class UnionFind {
private:
    unordered_map<string, string> parent;  // 存储每个节点的父节点
    unordered_map<string, int> rank;       // 存储每个集合的秩（树的高度）

public:
    // 构造函数，初始化并查集
    UnionFind(const vector<string>& nodes) {
        for (const string& node : nodes) {
            parent[node] = node;  // 初始时每个节点的父节点是自身
            rank[node] = 1;       // 初始秩为 1
        }
    }
    
    // 查找节点所属集合的根节点，并进行路径压缩
    string find(const string& node) {
        if (parent[node] != node) {
            parent[node] = find(parent[node]);  // 路径压缩
        }
        return parent[node];
    }
    
    // 合并两个节点所属的集合
    bool unionSets(const string& node1, const string& node2) {
        string root1 = find(node1);
        string root2 = find(node2);
        
        if (root1 == root2) {
            return false;  // 已在同一集合，合并失败
        }
        
        // 按秩合并：将秩较小的树合并到秩较大的树上
        if (rank[root1] > rank[root2]) {
            parent[root2] = root1;
        } else {
            parent[root1] = root2;
            if (rank[root1] == rank[root2]) {
                rank[root2]++;
            }
        }
        return true;  // 合并成功
    }
};

// Kruskal 算法实现
vector<Edge> kruskal(const unordered_map<string, vector<pair<string, int>>>& graph) {
    vector<Edge> edges;  // 存储所有边
    vector<string> nodes;  // 存储所有节点
    
    // 提取所有节点
    for (const auto& entry : graph) {
        nodes.push_back(entry.first);
    }
    
    // 提取所有边并去重
    unordered_map<string, bool> seen;  // 用于去重
    for (const auto& entry : graph) {
        string src = entry.first;
        for (const auto& neighbor : entry.second) {
            string dest = neighbor.first;
            int weight = neighbor.second;
            
            // 确保边只被添加一次（避免无向图中的重复）
            string edgeKey1 = src + "-" + dest;
            string edgeKey2 = dest + "-" + src;
            
            if (!seen[edgeKey1] && !seen[edgeKey2]) {
                edges.push_back({src, dest, weight});
                seen[edgeKey1] = true;
                seen[edgeKey2] = true;
            }
        }
    }
    
    // 按权重升序排序边
    sort(edges.begin(), edges.end());
    
    // 初始化并查集
    UnionFind uf(nodes);
    vector<Edge> mst;  // 存储最小生成树的边
    
    // 遍历排序后的边，选择不形成环的边加入 MST
    for (const Edge& edge : edges) {
        if (uf.find(edge.src) != uf.find(edge.dest)) {
            uf.unionSets(edge.src, edge.dest);
            mst.push_back(edge);
            
            // 提前终止：当 MST 的边数等于节点数减 1 时完成
            if (mst.size() == nodes.size() - 1) {
                break;
            }
        }
    }
    
    return mst;
}

四、工程实践要点

性能优化策略

• 内存映射技术：处理超大规模边集时使用mmap加载数据
• 并行排序：利用多线程加速边排序过程
• 批量合并：优化并查集的合并操作顺序

特殊场景处理

• 浮点权重处理：采用定点数存储避免精度误差累积
• 动态图维护：增量式更新已排序边集合
• 流式数据输入：外排序处理超出内存容量的边数据

质量保证措施

• 自动验证生成树的连通性
• 校验总权重是否符合预期
• 内存越界检测机制