6)图[2]Prim算法[最小生成树]

Prim 算法

求解方法：

首先将所指定的起点作为已选顶点，然后反复在满足如下条件下的边中选择一条最小边，直到

所有顶点已成为已选顶点为止（选择n-1条边）。

#include "iostream"
using namespace std;

typedef char Vertextype;//顶点类型
typedef int Edgetype;//边的权值类型

const int maxvex = 100;//最大顶点数目
const int infinity = 65535;//无穷大

typedef struct
{
    Vertextype vexs[maxvex];//图的定点存储
    Edgetype edge[maxvex][maxvex];//图的边
    int numVerTex,numEdge;//图的顶点数和边数
}graph;

typedef struct{//候选边存储结构
    Vertextype vertex;//未选定点对应候选边的另一顶点
    int weight;//未选顶点对应候选边的权值
}MinEdgeType;

typedef MinEdgeType MinEdgeArray[maxvex];//候选边的结构

/*
*图G中是否存在边(v,u)
*/
bool have_edge( graph  *&g,int v,int u)
{
    if(g->edge[v][u]!=infinity)return true;
    else return false;
}

/*
*初始化顶点v0候选边集
*/
int Init_MinEdges(graph *&g,MinEdgeArray &MinEdges,int v0)
{
    int i;
    for(i=0;i<g->numVerTex;i++)//初始化每个未选顶点随影的候选边的相关信息
    {
        if(have_edge(g,v0,i))//若G中存在边（v0,i）,设置顶点i到起点v0的候选信息，内容包括
        {
            MinEdges[i].vertex = g->vexs[v0];
            MinEdges[i].weight = g->edge[v0][i];//另一短点以及相应的权值
        }else MinEdges[i].weight = infinity;//否则,（v0,i）边不存在
    }
    return 0;
}

/*
*判断顶点v是否被选择
*/
bool judge(Vertextype v,Vertextype select[],int n)
{
    int i;
    bool flags = true;
    for(i=0;i<n;i++)
    {
        if(select[i]==v)
        {
            flags = false;
            break;
        }
    }
    return flags;
}

/*
*从候选边集中选出最短的顶点
*/
int Get_MinEdge(graph *&g,MinEdgeArray &MinEdges,Vertextype select[],int n)
{
    int MMin,i,k;
    MMin = infinity;
    for(i=0;i<g->numVerTex;i++)
    {
        if((judge(g->vexs[i],select,n))&&(MinEdges[i].weight<=MMin))
        {
            k = i;
            MMin = MinEdges[i].weight;
        }
    }
    return k;
}

/*
*对新选出的候选顶点k调整当前候选边集
*/
int change_MinEdge_with(graph *&g,MinEdgeArray &MinEdges,int k,Vertextype select[],int n)
{
    int i;
    for(i=0;i<g->numVerTex;i++)
    {
        if(judge(g->vexs[i],select,n))//i是未选定点
        {
            if(have_edge(g,k,i)&&(g->edge[k][i]<MinEdges[i].weight))//若i到k有更小的边
            {
                MinEdges[i].vertex = g->vexs[k];
                MinEdges[i].weight = g->edge[k][i];
            }
        }
    }
    return 0;
}

/*
*prim
*/
int prim(graph *&g,int v0)
{
    int count = 0;
    Vertextype select_vertex[maxvex];
    MinEdgeArray MinEdges;
    int i,j,k;
    select_vertex[count++] = g->vexs[v0];
    Init_MinEdges(g,MinEdges,v0);
    for(i=0;i<g->numVerTex-1;i++)
    {
        k = Get_MinEdge(g,MinEdges,select_vertex,count);
        select_vertex[count++] = g->vexs[k];
        change_MinEdge_with(g,MinEdges,k,select_vertex,count);
    }
    cout<<"Prim:";
    for(i=0;i<count;i++){
        if(i!=count-1)cout<<select_vertex[i]<<"->";
        else cout<<select_vertex[i]<<endl;
    }
    cout<<endl;
    return 0;
}
int create(graph *&g)
{
    int i,j,k,weight;
    cout<<"input numVerTex(顶点数):";
    cin>>g->numVerTex;
    cout<<"input numEdge(边数):";
    cin>>g->numEdge;
    cout<<"input(各顶点):"<<endl;
    for(i=0;i<g->numVerTex;i++)
    { 
        cin>>g->vexs[i];
    }
    for(i=0;i<g->numVerTex;i++)
    {
        for(j=0;j<g->numEdge;j++)
        {
            g->edge[i][j] = infinity;
        }
    }
    cout<<"input(各边两个顶点对应的下标和权值i,j,weight,edge[i][j]=weight):"<<endl;
    for(k=0;k<g->numEdge;k++)
    {
        cout<<"i,j,weight:";
        cin>>i>>j>>weight;
        g->edge[i][j] = weight;
        g->edge[j][i] = weight;

    }
    cout<<endl;
    return 0;
}

int main()
{
    graph *g  = new graph;
    create(g);
    Vertextype invertex;
    int start;
    cout<<"input start invertex:";
    cin>>invertex;

    for(int i=0;i<g->numVerTex;i++)
    {
        if(g->vexs[i]==invertex){
            start = i;
        }
    }
    prim(g,start);
    return  0;
}