走进数据结构和算法（c++版）（10）——最小生成树

最小生成树

  在生活中我们可能会遇到诸如多个地点架设通信网络、水管等等问题，如何设计出最小的成本的方案？
        

$$图1$$

  上图是一个带权值的图，即网结构。所谓的最小成本，就是$n$个顶点，用$n-1$条边把一个连通图连接起来，并且使得权值的和最小。像这样把构造连通网的最小代价生成树称为最小生成树( Minimun Cost Spanning Tree)。

  找连通网的最小生成树，经典的有两种算法，普里姆算法和克鲁斯卡尔算法。

普里姆( Prim )算法

  假设$N= ( P，\left \{E \right \} )$是连通网，$TE$ 是$N$上最小生成树中边的集合。算法从$U=\left \{ u_0 \right \}(u_0\epsilon V)$， $TE=\left \{ \right \}$开始。重复执行下述操作:在所有$u\epsilon U,v\epsilon V-U$的边$( u，v)\epsilon E$ 中找一条代价最小的边$(u_0，v_0)$并入集合$TE$ ，同时$v_0$ 并入$U$，直至$U=V$为止。此时$TE$中必有$n - 1$条边，则$T= (V,\left \{TE \right \})$为$N$的最小生成树。相关代码如下：

void Graph::MiniSpanTree_Prim()//Prim 算法生成最小生成树
{
    vector<int> adjvex;//保存顶点下标
    vector<int> lowcost;//保存顶点间边的权值
    int min,j,k;
    lowcost.push_back(0);
    adjvex.push_back(0);
    for (int i =1; i < numVertexes; i++)
    {
        lowcost.push_back(arc[0][i]);
        adjvex.push_back(0);
    }
    for (int i = 1; i < numVertexes; i++)
    {
        min = INFINITY;
        j = 1; k = 0;
        while (j < numVertexes)
        {
            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 < numVertexes; j++)
        {
            if (lowcost[j] != 0 && arc[k][j] < lowcost[j])
            {
                lowcost[j] = arc[k][j];
                adjvex[j] = k;
            }
        }
    }
}

#include<iostream>
#include "Graph.h"
using namespace std;

int main()
{
    Graph G;
    G.CreateGraph();
    cout << "最小生成树：" << endl;
    G.MiniSpanTree_Prim();
    system("pause");
    return 0;
}

  Graph类的相关定义可以看上一篇文（走进数据结构和算法（c++版）（9）——图）中关于邻接矩阵的代码。输入图1中的网图，在VS下运行结果如下：

克鲁斯卡尔( Kruskal )算法

  假设$N= ( V，\left \{E \right \} )$是连通网，则令最小生成树的初始状态为只有$n$个顶点而无边的非连通图$T=\left \{ V,\left \{ \right \} \right \}$，图中每个顶点自成一个连通分量。在$E$中选择代价最小的边，若该边依附的顶点落在$T$ 中不同的连通分量上，则将此边加入到$T$中，否则舍去此边而选择下一条代价最小的边。依次类推，直至$T$中所有顶点都在同一连通分量上为止。相关代码如下：

bool comp(Edge a, Edge b)//比较函数
{
    return a.weight < b.weight;
}
void Graph::MiniSpanTree_Kruskal()//Kruskal算法生成最小生成树
{
    int n, m;
    vector<Edge> edges;
    Edge e;
    vector<int> parent;
    for (int i = 1; i < numVertexes; i++)//将邻接矩阵转化到边集数组
    {
        for (int j = 0; j < i; j++)
        {
            if (arc[i][j] != 0 && arc[i][j]!= INF)
            {
                if (i < j)
                {
                    e.begin = i;
                    e.end = j;
                }
                else
                {
                    e.begin = j;
                    e.end = i;
                }
                e.weight = arc[i][j];
                edges.push_back(e);
            }
        }
    }
    sort(edges.begin(),edges.end(),comp);//边集数组排序
    for (int i = 0; i < numVertexes; i++)
        parent.push_back(0);
    for (int i = 0; i < numEdges; i++)
    {
        n = Find(parent,edges[i].begin);
        m = Find(parent, edges[i].end);
        if (n != m)
        {
            parent[n] = m;
            cout << "(" << vexs[edges[i].begin] << "," << vexs[edges[i].end] << ")" << " " << edges[i].weight << endl;
        }
    }

}
int Graph::Find(vector<int> & parent, int f)
{
    while (parent[f]>0)
        f = parent[f];
    return f;
}

#include<iostream>
#include "Graph.h"
#include<algorithm>
using namespace std;

int main()
{

    Graph G;
    G.CreateGraph();
    cout << "最小生成树：" << endl;
    G.MiniSpanTree_Kruskal();
    system("pause");
    return 0;
}

  输入图1中的网图，在VS下运行结果如下：

两种算法比较

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