最小生成树

根据大话数据结构整理：

/**********************************
*输入：邻接矩阵vMatrix/边表vEdge
*输出：最小生成树
***********************************/

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define INF 65535

/*********Prim*************/
void Prim(vector<vector<int>> &vMatrix)
{
    vector<int> adjvex(vMatrix.size() + 1);
    vector<int> lowcost(vMatrix.size() + 1);
    for (unsigned i = 1; i < vMatrix.size(); i++)
        lowcost[i] = vMatrix[0][i];
    for (unsigned i = 1; i < vMatrix.size(); i++)
    {
        int min = INF;
        unsigned j = 1, k = 0;
        while (j < vMatrix.size())
        {
            if (lowcost[j] != 0 && lowcost[j] < min)
            {
                min = lowcost[j];
                k = j;
            }
            j++;
        }
        cout << adjvex[k] << " " << k << endl;
        lowcost[k] = 0;
        for (j = 1; j < vMatrix.size(); j++)
        {
            if (lowcost[j] != 0 && lowcost[j] > vMatrix[k][j])
            {
                lowcost[j] = vMatrix[k][j];
                adjvex[j] = k;
            }
        }
    }
}
/*********Kruskal****************/
struct CEdge
{
    int begin;
    int end;
    int weight;
};
bool sortEdge(CEdge a, CEdge b)
{
    return a.weight < b.weight;
}
int Find(vector<int> &parent, int f)
{
    while (parent[f]>0)
        f = parent[f];
    return f;
}
void Kruskal(vector<CEdge> &vEdge, int nodeNum)
{
    vector<int> parent(nodeNum + 1);
    for (unsigned i = 0; i < vEdge.size(); i++)
    {
        int n = Find(parent, vEdge[i].begin);
        int m = Find(parent, vEdge[i].end);
        if (n != m)
        {
            parent[n] = m;
            cout << vEdge[i].begin << " "
                << vEdge[i].end << " "
                << vEdge[i].weight << endl;
        }
    }
}
/*********主函数****************/
int main()
{   
    int nodeNum, N, data1, data2, data3;
    cin >> nodeNum >> N;
    /******建立邻接矩阵**********/
    vector<vector<int>> vMatrix(nodeNum, vector<int>(nodeNum, INF));
    for (int j = 0; j < nodeNum; j++)
        vMatrix[j][j] = 0;
    /*******建立权值边***************/
    vector<CEdge> vEdge(N);
    for (int i = 0; i < N; i++)
    {
        cin >> data1 >> data2 >> data3;
        vMatrix[data1][data2] = data3;
        vMatrix[data2][data1] = data3;
        vEdge[i].begin = data1;
        vEdge[i].end = data2;
        vEdge[i].weight = data3;
    }
    cout << "Prim最小生成树： " << endl;
    Prim(vMatrix);
    cout << "Kruskal最小生成树： " << endl;
    sort(vEdge.begin(), vEdge.end(), sortEdge);
    Kruskal(vEdge, nodeNum);
    return 0;
}
/*case:顶点数n,边数m,m条边*/
/*
9
15
0 1 10
0 5 11
1 2 18
1 8 12
1 6 16
2 3 22
2 8 8
3 4 20
3 7 16
3 6 24
3 8 21
4 5 26
4 7 7
5 6 17
6 7 19
*/