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-])
 {  edge x;
    int d,min,j,k,s,v;

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

    /*依次求当前(第k条）最小两栖边，并加入TE*/
    for(k=;k<=g.n-;k++)
    {
        min=tree[k].length;
        s=k;
        for(j=k+;j<=g.n-;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+;j<=g.n-;j++)
        {
            d=g.edges[v][tree[j].en];
            if(d<tree[j].length)
            {
                tree[j].length=d;
                tree[j].beg=v;
            }
        }
    }
    /*输出最小生成树*/
     printf("\n最小生成树是:\n");/*输出最小生成树*/
     for (j=;j<=g.n-;j++)
         printf("\n%c---%c  %d\n",g.vexs[tree[j].beg],g.vexs[tree[j].en],tree[j].length);
     printf("\n最小生成树的根是： %c\n", g.vexs[]);
  }

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

   }

 /********************************************/
 /*         邻接矩阵类型定义的头文件             */
 /*               文件名：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=;i<g->n;i++)    /*读入图中的顶点值*/
       fscanf(rf,"%1s",&g->vexs[i]);

    for(i=;i<g->n;i++)    /*初始化邻接矩阵*/
       for(j=;j<g->n;j++)
        if (i==j) g->edges[i][j]=;
        else g->edges[i][j]=FINITY;

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

 void  print(Mgraph g)
 {/*辅助函数，输出邻接矩阵表示的图g*/
   int i,j;

   for (i=;i<g.n;i++)
    { printf("%c ",g.vexs[i]);
     }
     printf("\n");
   for (i=;i<g.n;i++)
     {    for (j=;j<g.n;j++)
          {printf("%6d",g.edges[i][j]);
         }
           printf("\n");
        }
   }