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

Prim 算法

求解方法：

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

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

 #include "iostream"
 using namespace std;
 
 typedef char Vertextype;//顶点类型
 typedef int Edgetype;//边的权值类型
 
 const int maxvex = ;//最大顶点数目
 const int infinity = ;//无穷大
 
 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=;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 ;
 }
 
 /*
 *判断顶点v是否被选择
 */
 bool judge(Vertextype v,Vertextype select[],int n)
 {
     int i;
     bool flags = true;
     for(i=;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=;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=;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 ;
 }
 
 /*
 *prim
 */
 int prim(graph *&g,int v0)
 {
     int count = ;
     Vertextype select_vertex[maxvex];
     MinEdgeArray MinEdges;
     int i,j,k;
     select_vertex[count++] = g->vexs[v0];
     Init_MinEdges(g,MinEdges,v0);
     for(i=;i<g->numVerTex-;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=;i<count;i++){
         if(i!=count-)cout<<select_vertex[i]<<"->";
         else cout<<select_vertex[i]<<endl;
     }
     cout<<endl;
     return ;
 }
 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=;i<g->numVerTex;i++)
     {
         cin>>g->vexs[i];
     }
     for(i=;i<g->numVerTex;i++)
     {
         for(j=;j<g->numEdge;j++)
         {
             g->edge[i][j] = infinity;
         }
     }
     cout<<"input(各边两个顶点对应的下标和权值i,j,weight,edge[i][j]=weight):"<<endl;
     for(k=;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 ;
 }
 
 int main()
 {
     graph *g  = new graph;
     create(g);
     Vertextype invertex;
     int start;
     cout<<"input start invertex:";
     cin>>invertex;
 
     for(int i=;i<g->numVerTex;i++)
     {
         if(g->vexs[i]==invertex){
             start = i;
         }
     }
     prim(g,start);
     return  ;
 }