最小生成树

简介

我们把构造连通网的最小代价生成树称为最小生成树（Minimum Cost Spanning Tree）。

普里姆（Prim）算法

/* Prim算法生成最小生成树 */
void MiniSpanTree_Prim(MGraph G)
{
    int min, i, j, k;
    int adjvex[MAXVEX];     /* 保存相关顶点下标 */
    int lowcost[MAXVEX];    /* 保存相关顶点间边的权值 */
    lowcost[0] = 0;         /* 初始化第一个权值为0，即v0加入生成树 */
                            /* lowcost的值为0，在这里就是此下标的顶点已经加入生成树 */
    adjvex[0] = 0;          /* 初始化第一个顶点下标为0 */
    for (i=1; i<G.numVertexes; i++) /* 循环除下标为0外的全部顶点 */
    {
        lowcost[i] = G.arc[0][i];   /* 将v0顶点与之有边的权值存入数组 */
        adjvex[i] = 0;              /* 初始化都为v0的下标 */
    }
    for (i=1; i<G.numVertexes; i++)
    {
        min = INFINITY;     /* 初始化最小权值为∞，*/
                            /* 通常设置为不可能的大数字如32767、65535等 */
        j = 1;
        k = 0;
        while (j < G.numVertexes)           /* 循环全部顶点 */
        {
            if (lowcost[j]!=0 && lowcost[j]<min)
            {
                /* 如果权值不为0且权值小于min */
                min = lowcost[j];       /* 则让当前权值成为最小值 */
                k = j;                  /* 将当前最小值的下标存入k */
            }
            j++;
        }
        printf("(%d,%d)", adjvex[k], k);    /* 打印当前顶点边中权值最小边 */
        lowcost[k] = 0; /* 将当前顶点的权值设置为0，表示此顶点已经完成任务 */
        for (j=1; j<G.numVertexes; j++)     /* 循环所有顶点 */
        {
            if (lowcost[j]!=0 && G.arc[k][j]<lowcost[j])
            {
                /* 若下标为k顶点各边权值小于此前这些顶点未被加入生成树权值 */
                lowcost[j] = G.arc[k][j];   /* 将较小权值存入lowcost */
                adjvex[j] = k;          /* 将下标为k的顶点存入adjvex */
            }
        }
    }
}

• 算法从第一个顶点开始寻找离此顶点最近的一条边加入生成树，并用最近顶点的边更新边表数据，再从边表数据找到最短的一条边加入生成树，再更新边表数据……直到第n-1条边加入生成树，算法结束。
• 算法的时间复杂度为O(n²)。

克鲁斯卡尔（Kruskal）算法

/* 对边集数组Edge结构的定义 */
typedef struct
{
    int begin;
    int end;
    int weight;
}Edge;

/* Kruskal算法生成最小生成树 */
void MiniSpanTree_Kruskal(MGraph G) /* 生成最小生成树 */
{
    int i, n, m;
    Edge edges[MAXEDGE];    /* 定义边集数组 */
    int parent[MAXVEX];     /* 定义一数组用来判断边与边是否形成环路 */
    /* 此处省略将邻接矩阵G转化为边集数组edges并按权由小到大排序的代码 */
    for (i=0; i<G.numVertexes; i++)
        parent[i] = 0;      /* 初始化数组值为0 */
    for (i=0; i<G.numEdges; i++)    /* 循环每一条边 */
    {
        n = Find(parent, edges[i].begin);
        m = Find(parent, edges[i].end);
        if (n != m)     /* 假如n与m不等，说明此边没有与现有生成树形成环路 */
        {
            parent[n] = m;  /* 将此边的结尾顶点放入下标为起点的parent中 */
                            /* 表示此顶点已经在生成树集合中 */
            printf("(%d, %d) %d ", edges[i].begin,
                            edges[i].end, edges[i].weight);
        }
    }
}

int Find(int *parent, int f)    /* 查找连线顶点的尾部下标 */
{
    while (parent[f] > 0)
        f = parent[f];
    return f;
}

• 算法从排序好的边，依次选择一条不形成回路的边加入生成树中，直到每条边都遍历过。
• 此算法的时间复杂度为O(eloge)。

总结

对比两个算法，克鲁斯卡尔算法主要是针对边来展开，边数少时效率会非常高，所以对于稀疏图有很大的优势；而普里姆算法对于稠密图，即边数非常多的情况会更好一些。