prim算法求最小生成树程序

最新推荐文章于 2024-02-15 20:50:29 发布

原创最新推荐文章于 2024-02-15 20:50:29 发布 · 3.3k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #tree #graph #input #struct

算法&&我的程序专栏收录该内容

19 篇文章

订阅专栏

本文介绍了一种使用Prim算法寻找带权无向图最小生成树的方法。通过创建图的邻接矩阵并采用Prim算法逐步构建最小生成树，最终输出最小生成树的边及其权重总和。

//用prim算法求最小生成树
#include <stdio.h>
#define INFINITY 32767
#define MAX 4
typedef struct{
        int vexnum;
        int arcs[MAX][MAX];
        }Graph;//图的结构体
//*****************创建图的邻接矩阵 *****************
void Creat_Graph(Graph *g)
      {
             int i,j,v1,v2,w,num;
             printf("please input vertex number:/n");
             scanf("%d",&num);
             g->vexnum=num;
             for(i=0;i<num;i++)
                 for(j=0;j<num;j++)
                     if(i==j)
                        g->arcs[i][j]=0; //无环，对角线为0
                     else
                        g->arcs[i][j]=INFINITY;
              printf("please input vertex ,vertex ,weight :(end with -1,-1)/n");
              do
                {     printf("<vertex1,vertex2,weight>:");
                      scanf("%d,%d,%d",&v1,&v2,&w);
                      if(v1>=0&&v1<num&&v2>=0&&v2<num)
                          {
                                 g->arcs[v1][v2]=w;
                                 g->arcs[v2][v1]=w;
                          }
                }while(!(v1==-1&&v2==-1));//循环的条件
     }
//***************求最小生成树**********************
int MiniSpanTree_PRIM(Graph g,int v,int tree[][3])//为什么不能用*g
      {
          int i,j,cost,p,min;
          int k;
          int lowcost[MAX],closevex[MAX];
          for(i=0;i<g.vexnum;i++)
              {
                      closevex[i]=v;
                      lowcost[i]=g.arcs[v][i];
              }
              cost=0;
              p=0;
             for(i=0;i<g.vexnum-1;i++)
                  {
                         min=INFINITY;
                         for(j=0;j<g.vexnum;j++)
                             if(lowcost[j]!=0&&lowcost[j]<min)
                                 {
                                         min=lowcost[j];
                                         k=j;
                                 }
                              tree[p][0]=closevex[k];
                              tree[p][1]=k;
                              tree[p][2]=min;
                              p++;
                              cost=cost+min;
                              lowcost[k]=0;
                        for(j=0;j<g.vexnum;j++)
                            if(g.arcs[k][j]!=0&&g.arcs[k][j]<lowcost[j])
                                {
                                       lowcost[j]=g.arcs[k][j];
                                        closevex[j]=k;
                                }
                 }
                 return cost;
       }
    //****************主函数******************************
    int main()
       {
              int tree[MAX][3];
              int k,cost;
              Graph g;
               Creat_Graph(&g);
              cost=MiniSpanTree_PRIM(g,1,tree);
              printf("The Minimum Cost Spanning Tree is/n");
              printf(" edg       weigth/n");
              for(k=0;k<g.vexnum-1;k++)
              printf("V%d--V%d        %d/n",tree[k][0],tree[k][1],tree[k][2]);
              printf("The tree Cost :%d /n",cost);
              getch();
              return 0;
       }