算法分析与设计：最小生成树算法—— (Prim) VS (Kruskal)

最小生成树

一个有 $n$ 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 $n$ 个结点，并且有保持图连通的最少的边。 最小生成树可以用 Kruskal（克鲁斯卡尔）算法或 Prim（普里姆）算法求出。

---

Prim 算法（加点法）

此算法可以称为加点法，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点 $s$ 开始，逐渐长大覆盖整个连通网的所有顶点。

Prim 算法将所有顶点分成两个部分 $A$ 和 $B$，$A$ 为目标集合，该算法可以看成是不断将 $B$ 中顶点向 $A$ 集合转移的过程，在该过程中，不断更新 $B$ 中各顶点到 $A$ 树的最短距离，并将其排序，按照贪心思想将具有最短路径并且不会产生回路的那个顶点从 $B$ 中移向 $A$ 中。

---

Kruskal 算法（加边法）

Kruska 算法将多个顶点分成 $N$ 个部分，该算法可以看成是不断将 $N$ 个部分进行合并的过程，在该过程中，先将边按照权重进行排序，再按照贪心思想依次将具有最短权重且不会产生回路的顶点进行合并。

此算法可以称为加边法，初始最小生成树边数为0，每迭代一次就选择一条满足条件（不形成回路）的最小代价边，加入到最小生成树的边集合里。

---

总结

Kruskal 算法与 Prim 算法的不同之处在于，Kruskal 在找最小生成树结点之前，需要对所有权重边做从小到大排序。将排序好的权重边依次加入到最小生成树中，如果加入时产生回路就跳过这条边，加入下一条边。当所有结点都加入到最小生成树中之后，就找出了最小生成树。

Kruskal 算法在效率上要比 Prim 算法快，因为 Kruskal 只需要对权重边做一次排序，而 Prim 算法则需要做多次排序。

---

完整代码

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
#define INFINITE 0xFFFFFFFF     // 无穷大
#define VertexData unsigned int // 顶点数据
#define UINT unsigned int
#define N 6 // 顶点数量
char vextex[] = {'A', 'B', 'C', 'D', 'E', 'F'};

class node
{
public:
    VertexData data;         // 顶点数据
    unsigned int lowestcost; // 最小边的代价
};
node closedge[N]; // Prim算法中的辅助信息

// 原始图的边信息
class Arc
{
public:
    VertexData u;
    VertexData v;
    unsigned int cost; // 边的代价
    bool operator<(Arc &arc) const { return cost < arc.cost; }
};

//邻接矩阵表示(数据初始化)
void AdjMatrix(unsigned int adjMat[][N])
{
    for (int i = 0; i < N; ++i) //初始化邻接矩阵
        for (int j = 0; j < N; j++)
        {
            adjMat[i][j] = INFINITE; // 所有的路径都是无穷大
        }
    adjMat[0][1] = 6;
    adjMat[0][2] = 1;
    adjMat[0][3] = 5;
    adjMat[1][0] = 6;
    adjMat[1][2] = 5;
    adjMat[1][4] = 3;
    adjMat[2][0] = 1;
    adjMat[2][1] = 5;
    adjMat[2][3] = 5;
    adjMat[2][4] = 6;
    adjMat[2][5] = 4;
    adjMat[3][0] = 5;
    adjMat[3][2] = 5;
    adjMat[3][5] = 2;
    adjMat[4][1] = 3;
    adjMat[4][2] = 6;
    adjMat[4][5] = 6;
    adjMat[5][2] = 4;
    adjMat[5][3] = 2;
    adjMat[5][4] = 6;
}

// 返回最小代价边的索引
int Minmum(struct node *closedge)
{
    unsigned int min = INFINITE;
    int index = -1;
    for (int i = 0; i < N; ++i)
    {
        if (closedge[i].lowestcost < min && closedge[i].lowestcost != 0)
        {
            min = closedge[i].lowestcost;
            index = i;
        }
    }
    return index;
}

// 保存图的边代价信息
void ReadArc(unsigned int adjMat[][N], vector<Arc> &vertexArc)
{
    Arc *temp = NULL;
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < i; j++)
        {
            if (adjMat[i][j] != INFINITE)
            {
                temp = new Arc;
                temp->u = i;
                temp->v = j;
                temp->cost = adjMat[i][j];
                vertexArc.push_back(*temp);
            }
        }
    }
}

// 检查此边的两个顶点是否在一颗树内(是否构成回路)
bool FindTree(VertexData u, VertexData v, vector<vector<VertexData>> &Tree)
{
    int index_u = INFINITE;
    int index_v = INFINITE;
    for (unsigned int i = 0; i < Tree.size(); ++i) //检查u,v分别属于哪颗树
    {
        if (find(Tree[i].begin(), Tree[i].end(), u) != Tree[i].end())
            index_u = i;
        if (find(Tree[i].begin(), Tree[i].end(), v) != Tree[i].end())
            index_v = i;
    }

    if (index_u != index_v) //u,v不在一颗树上，合并两颗树
    {
        for (unsigned int i = 0; i < Tree[index_v].size(); ++i)
        {
            Tree[index_u].push_back(Tree[index_v][i]);
        }
        Tree[index_v].clear();
        return true;
    }
    return false;
}

/*****************************************************************
* 函数描述： Prim 最小生成树算法
* 函数参数： adjMat —— 邻接矩阵
            s —— 起点
* 函数返回： void
*****************************************************************/
void Prim(unsigned int adjMat[][N], VertexData s)
{
    for (int i = 0; i < N; ++i)
    {
        closedge[i].lowestcost = INFINITE;
    }
    closedge[s].data = s; // 从顶点s开始
    closedge[s].lowestcost = 0;
    for (int i = 0; i < N; ++i) //初始化辅助数组
    {
        if (i != s)
        {
            closedge[i].data = s;
            closedge[i].lowestcost = adjMat[s][i];
        }
    }
    for (int e = 1; e <= N - 1; ++e) //n-1条边时退出
    {
        int k = Minmum(closedge);                                       //选择最小代价边
        cout << vextex[closedge[k].data] << "---" << vextex[k] << endl; //加入到最小生成树
        closedge[k].lowestcost = 0;                                     //代价置为0
        for (int i = 0; i < N; ++i)                                     //更新v中顶点最小代价边信息
        {
            if (adjMat[k][i] < closedge[i].lowestcost)
            {
                closedge[i].data = k;
                closedge[i].lowestcost = adjMat[k][i];
            }
        }
    }
}

/*****************************************************************
* 函数描述： Kruskal 最小生成树算法
* 函数参数： adjMat —— 邻接矩阵
* 函数返回： void
*****************************************************************/
void Kruskal(unsigned int adjMat[][N])
{
    vector<Arc> vertexArc;
    ReadArc(adjMat, vertexArc);               //读取边信息，将邻接矩阵转换为Arc类型的向量
    sort(vertexArc.begin(), vertexArc.end()); //边按从小到大排序
    vector<vector<VertexData>> Tree(N);       //6棵独立树
    for (unsigned int i = 0; i < N; ++i)
    {
        Tree[i].push_back(i); //初始化6棵独立树的信息
    }
    for (unsigned int i = 0; i < vertexArc.size(); ++i) //依次从小到大取最小代价边
    {
        VertexData u = vertexArc[i].u;
        VertexData v = vertexArc[i].v;
        if (FindTree(u, v, Tree)) // 检查此边的两个顶点是否在一颗树内
        {
            cout << vextex[u] << "---" << vextex[v] << endl; //把此边加入到最小生成树中
        }
    }
}

int main()
{
    unsigned int adjMat[N][N] = {0};
    AdjMatrix(adjMat); //邻接矩阵
    cout << "Prim:" << endl;
    Prim(adjMat, 0); //Prim算法，从顶点0开始.
    cout << "-------------\n"
         << "Kruskal:" << endl;
    Kruskal(adjMat); //Kruskal算法
    return 0;
}

---

Reference

• https://www.cnblogs.com/lab-hit/archive/2012/04/04/2431937.html
• https://blog.csdn.net/luoshixian099/article/details/51908175/