Prim求解最小生成树

#include "ljjz.h"

typedef struct edgedata  /*用于保存最小生成树的边类型定义*/
       { int beg,en;     /*beg,en是边顶点序号*/
         int length;     /*边长*/
       }edge;

/*函数功能：prim算法构造最小生成树
函数参数：图的邻接矩阵g;边向量edge
*/
void prim(Mgraph g, edge tree[M-1])
{  edge x;
   int d,min,j,k,s,v;

   /* 建立初始入选点，并初始化生成树边集tree*/
   for(v=1;v<=g.n-1;v++)
   {
       tree[v-1].beg=0;
       tree[v-1].en=v;
       tree[v-1].length=g.edges[0][v];
   }

   /*依次求当前(第k条）最小两栖边，并加入TE*/
   for(k=0;k<=g.n-3;k++)
   {
       min=tree[k].length;
       s=k;
       for(j=k+1;j<=g.n-2;j++)
           if(tree[j].length<min)
           {
               min=tree[j].length;
               s=j;
           }
       v=tree[s].en;
       x=tree[s];
       tree[s]=tree[k];
       tree[k]=x;

   /*由于新顶点v的加入，修改两栖边的基本信息*/
       for(j=k+1;j<=g.n-2;j++)
       {
           d=g.edges[v][tree[j].en];
           if(d<tree[j].length)
           {
               tree[j].length=d;
               tree[j].beg=v;
           }
       }
   }
   /*输出最小生成树*/
    printf("
最小生成树是:
");/*输出最小生成树*/
    for (j=0;j<=g.n-2;j++)
        printf("
%c---%c  %d
",g.vexs[tree[j].beg],g.vexs[tree[j].en],tree[j].length);
    printf("
最小生成树的根是： %c
", g.vexs[0]);
 }

int  main()
  {
   Mgraph g;
   edge  tree[M-1];  /*用于存放最小生成树的M-1条边*/
   creat(&g,"g.txt",0);  /*创建无向图的邻接矩阵*/
   prim(g,tree);        /*求解图的最小生成树*/
   return 0;

  }

/********************************************/
/*         邻接矩阵类型定义的头文件             */
/*               文件名：ljjz.h                   */
/********************************************/

#include <stdio.h>
#define FINITY 5000               /*此处用5000代表无穷大*/
#define M 20                          /*最大顶点数*/
typedef char vertextype;          /*顶点值类型*/
typedef int edgetype;             /*权值类型*/
typedef struct{
    vertextype vexs[M];            /*顶点信息域*/
    edgetype edges[M][M];     /*邻接矩阵*/
    int n,e;                              /*图中顶点总数与边数*/
} Mgraph;                               /*邻接矩阵表示的图类型*/
/*   函数功能：建立图的邻接矩阵存储结构
     函数参数：邻接矩阵的指针变量g；存放图信息的文件名s；图的类型c，c=0表示建立无向图，否则表示建立有向图 
   函数返回值：无
*/ 
void creat(Mgraph *g,char *s ,int c)
{int i,j,k,w;           /*建立网络的邻接矩阵存储结构*/
   FILE *rf ;
   rf = fopen(s, "r") ;   /*从文件中读取图的边信息*/
   if (rf)
   {
   fscanf(rf,"%d%d",&g->n,&g->e);  /*读入图的顶点数与边数*/
   for(i=0;i<g->n;i++)    /*读入图中的顶点值*/
      fscanf(rf,"%1s",&g->vexs[i]);
 
   for(i=0;i<g->n;i++)    /*初始化邻接矩阵*/
      for(j=0;j<g->n;j++)
       if (i==j) g->edges[i][j]=0;
       else g->edges[i][j]=FINITY;

   for (k=0;k<g->e;k++)  /*读入网络中的边*/
    {fscanf(rf,"%d%d%d", &i,&j,&w);
     g->edges[i][j]=w;
     if (c==0) g->edges[j][i]=w;   /*如果C==0则建立无向图邻接矩阵，否则建立有向图邻矩阵*/
    }
   fclose(rf);
   }
   else g->n=0;
}


void  print(Mgraph g)
{/*辅助函数，输出邻接矩阵表示的图g*/
  int i,j;
 
  for (i=0;i<g.n;i++)
   { printf("%c ",g.vexs[i]); 
    }
    printf("
");
  for (i=0;i<g.n;i++)
    {    for (j=0;j<g.n;j++)
         {printf("%6d",g.edges[i][j]);
        }
          printf("
");
       }
  }