图的最小生成树之普里姆和克鲁斯卡尔算法

普里姆（Prim）和克鲁斯卡尔（Kruskal）算法

这两种算法都是来求图的最小生成树，先来张图的图片吧（来源于书上）

普里姆算法

从图的一个顶点出发，寻找到与该顶点构成的权值最小的邻接顶点，然后将该邻接顶点存放到，一该顶点数字标识符为索引的数组下，且将读到的权值存入权值数组中（无论有无权值）来标记顶点已加入生成树中；就这样依次循环。

该算法中由于循环嵌套非常明显，经过估算其时间复杂度为 O(n^2);

上图生形成最小生成树的图如下

代码：

void MiniSpanTree_Prime(MGraph G)
{
    int adjvex[MAXVEX];             //保存某顶点的有效邻接顶点下标
    int lowcost[MAXVEX];            //保存相关顶点间的边的权值
    lowcost[0] = 0;                 //从下标为0的顶点出发（更方便操作）
    adjvex[0] = 0;                  //初始化第一个顶点的下标为0

    for (int i = 1; i < G.numVertexes; i++)
    {
        lowcost[i] = G.arc[0][i];    //将V0顶点与之有边的权值存入数组
        adjvex[i] = 0;               //初始化全部都为V0的下标
    }

    int Min;
    int j, k;
    for (int i = 1; i < G.numVertexes; i++)
    {
        Min = INFINITY;
        j = 1; k = 0;
        while (j < G.numVertexes)
        {
            if (lowcost[j] != 0 && lowcost[j] < Min)
            {
                Min = lowcost[j];       //取最小权值
                k = j;                  //去最小值的下标
            }
            ++j;
        }

        printf("%c ---> %c  ", G.vexs[adjvex[k]], G.vexs[k]);
        lowcost[k] = 0;

        for (int j = 1; j < G.numVertexes; j++)
        {
            if (lowcost[j] != 0 && G.arc[k][j] < lowcost[j])
            {
                //更新生成树权值
                lowcost[j] = G.arc[k][j];   //将比之前小的权值存入
                adjvex[j] = k;              //存入此顶点的上一个邻接顶点
            }
        }
    }
}

克鲁斯卡尔算法

该算法就不像普里姆那样对顶点进行广撒网（也就是将一个顶点的周边都检查一遍），克鲁斯卡尔是对整理好的边进行遍历，其中整理好的意思就是将每条边按权值的大小进行由小到大排序，其中很危险的就是要防止形成环。

来看下图

其最小生成树的图片和上面的普里姆算法的一样

代码

typedef struct{
    int Begin;
    int End;
    int weight;
}Edge;

Edge* get_edges(MGraph G)
{
    Edge *edges;
    int index = 0;

    edges = (Edge *)malloc(sizeof(Edge) * G.numEdges);
    for (int i = 0; i < G.numVertexes; i++)
    {
        for (int j = i + 1; j < G.numVertexes; j++)
        {
            if (G.arc[i][j] != INFINITY)
            {
                edges[index].Begin = i;
                edges[index].End = j;
                edges[index].weight = G.arc[i][j];
                ++index;
            }
        }
    }
    return edges;
}

void sorted_edges(Edge *edges, int GEdges)
{
    for (int i = 0; i < GEdges; i++)
    {
        for (int j = i + 1; j < GEdges; j++)
        {
            if (edges[i].weight > edges[j].weight)
            {
                Edge tmp = edges[i];
                edges[i] = edges[j];
                edges[j] = tmp;
            }
        }
    }
}

int Find(int *parent, int f)
{
    while(parent[f] > 0)
    {
        f = parent[f];
    }
    return f;
}

void MiniSpanTree_Kruska1(MGraph G)
{
    int m, n;
    int parent[MAXVEX];   //用来判断边与边是否形成环路
    Edge *edges;   //图中的所有边
    edges = get_edges(G);
    //将边排序
    sorted_edges(edges, G.numEdges);

    for (int i = 0; i < G.numVertexes; i++)
    {
        parent[i] = 0;  //初始化
    }

    for (int i = 0; i < G.numEdges; i++)
    {
        n = Find(parent, edges[i].Begin);
        m = Find(parent, edges[i].End);
        if (m != n)
        {
            parent[n] = m;
            printf("(%c, %c) %d ", G.vexs[edges[i].Begin], G.vexs[edges[i].End], edges[i].weight);
        }
    }
}

克鲁斯卡尔算法的时间复杂度主要还是与图的边的数量有很大的关系，复杂度为 O(nlogn);

以上代码可以整合到之前创建图的代码中，之前的总结记录中有。

在图的边比较少时（也就是稀疏图时）适合用克鲁斯卡尔算法，而对于稠密图就适合普里姆算法了