第十三周项目1-Prim算法的验证

/*  
 * Copyright (c) 2016, 烟台大学计算机与控制工程学院  
 * All rights reserved。  
 * 文件名称 ：1.cpp  
 * 作    者 ：杨俊杰  
 * 完成日期 ：2016年 11月24日  
 * 版 本 号 ：v1.0  
 * 问题描述 ： Prim算法的验证
 * 输出描述 ：

 */

[cpp]  view plain  copy

 

1. //1.头文件：graph.h，包含定义图数据结构的代码、宏定义、要实现算法的函数的声明；    
2.     
3. #ifndef GRAPH_H_INCLUDED    
4. #define GRAPH_H_INCLUDED    
5.     
6. #define MAXV 100                //最大顶点个数    
7. #define INF 32767       //INF表示∞    
8. typedef int InfoType;    
9.     
10. //以下定义邻接矩阵类型    
11. typedef struct    
12. {    
13.     int no;                     //顶点编号    
14.     InfoType info;              //顶点其他信息，在此存放带权图权值    
15. } VertexType;                   //顶点类型    
16.     
17. typedef struct                  //图的定义    
18. {    
19.     int edges[MAXV][MAXV];      //邻接矩阵    
20.     int n,e;                    //顶点数，弧数    
21.     VertexType vexs[MAXV];      //存放顶点信息    
22. } MGraph;                       //图的邻接矩阵类型    
23.     
24. //以下定义邻接表类型    
25. typedef struct ANode            //弧的结点结构类型    
26. {    
27.     int adjvex;                 //该弧的终点位置    
28.     struct ANode *nextarc;      //指向下一条弧的指针    
29.     InfoType info;              //该弧的相关信息,这里用于存放权值    
30. } ArcNode;    
31.     
32. typedef int Vertex;    
33.     
34. typedef struct Vnode            //邻接表头结点的类型    
35. {    
36.     Vertex data;                //顶点信息    
37.     int count;                  //存放顶点入度,只在拓扑排序中用    
38.     ArcNode *firstarc;          //指向第一条弧    
39. } VNode;    
40.     
41. typedef VNode AdjList[MAXV];    //AdjList是邻接表类型    
42.     
43. typedef struct    
44. {    
45.     AdjList adjlist;            //邻接表    
46.     int n,e;                    //图中顶点数n和边数e    
47. } ALGraph;                      //图的邻接表类型    
48.     
49. //功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图    
50. //参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）    
51. //      n - 矩阵的阶数    
52. //      g - 要构造出来的邻接矩阵数据结构    
53. void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵    
54. void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表    
55. void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G    
56. void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g    
57. void DispMat(MGraph g);//输出邻接矩阵g    
58. void DispAdj(ALGraph *G);//输出邻接表G    
59.     
60. #endif // GRAPH_H_INCLUDED    

[cpp]  view plain  copy

 

1. //2.源文件：graph.cpp，包含实现各种算法的函数的定义    
2.     
3. #include <stdio.h>    
4. #include <malloc.h>    
5. #include "graph.h"    
6.     
7. //功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图    
8. //参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）    
9. //      n - 矩阵的阶数    
10. //      g - 要构造出来的邻接矩阵数据结构    
11. void ArrayToMat(int *Arr, int n, MGraph &g)    
12. {    
13.     int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数    
14.     g.n=n;    
15.     for (i=0; i<g.n; i++)    
16.         for (j=0; j<g.n; j++)    
17.         {    
18.             g.edges[i][j]=Arr[i*n+j]; //将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]，计算存储位置的功夫在此应用    
19.             if(g.edges[i][j]!=0 && g.edges[i][j]!=INF)    
20.                 count++;    
21.         }    
22.     g.e=count;    
23. }    
24.     
25. void ArrayToList(int *Arr, int n, ALGraph *&G)    
26. {    
27.     int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数    
28.     ArcNode *p;    
29.     G=(ALGraph *)malloc(sizeof(ALGraph));    
30.     G->n=n;    
31.     for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值    
32.         G->adjlist[i].firstarc=NULL;    
33.     for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素    
34.         for (j=n-1; j>=0; j--)    
35.             if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]    
36.             {    
37.                 p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p    
38.                 p->adjvex=j;    
39.                 p->info=Arr[i*n+j];    
40.                 p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p    
41.                 G->adjlist[i].firstarc=p;    
42.             }    
43.     
44.     G->e=count;    
45. }    
46.     
47. void MatToList(MGraph g, ALGraph *&G)    
48. //将邻接矩阵g转换成邻接表G    
49. {    
50.     int i,j;    
51.     ArcNode *p;    
52.     G=(ALGraph *)malloc(sizeof(ALGraph));    
53.     for (i=0; i<g.n; i++)                   //给邻接表中所有头节点的指针域置初值    
54.         G->adjlist[i].firstarc=NULL;    
55.     for (i=0; i<g.n; i++)                   //检查邻接矩阵中每个元素    
56.         for (j=g.n-1; j>=0; j--)    
57.             if (g.edges[i][j]!=0)       //存在一条边    
58.             {    
59.                 p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p    
60.                 p->adjvex=j;    
61.                 p->info=g.edges[i][j];    
62.                 p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p    
63.                 G->adjlist[i].firstarc=p;    
64.             }    
65.     G->n=g.n;    
66.     G->e=g.e;    
67. }    
68.     
69. void ListToMat(ALGraph *G,MGraph &g)    
70. //将邻接表G转换成邻接矩阵g    
71. {    
72.     int i,j;    
73.     ArcNode *p;    
74.     g.n=G->n;   //根据一楼同学“举报”改的。g.n未赋值，下面的初始化不起作用    
75.     g.e=G->e;    
76.     for (i=0; i<g.n; i++)   //先初始化邻接矩阵    
77.         for (j=0; j<g.n; j++)    
78.             g.edges[i][j]=0;    
79.     for (i=0; i<G->n; i++)  //根据邻接表，为邻接矩阵赋值    
80.     {    
81.         p=G->adjlist[i].firstarc;    
82.         while (p!=NULL)    
83.         {    
84.             g.edges[i][p->adjvex]=p->info;    
85.             p=p->nextarc;    
86.         }    
87.     }    
88. }    
89.     
90. void DispMat(MGraph g)    
91. //输出邻接矩阵g    
92. {    
93.     int i,j;    
94.     for (i=0; i<g.n; i++)    
95.     {    
96.         for (j=0; j<g.n; j++)    
97.             if (g.edges[i][j]==INF)    
98.                 printf("%3s","∞");    
99.             else    
100.                 printf("%3d",g.edges[i][j]);    
101.         printf("\n");    
102.     }    
103. }    
104.     
105. void DispAdj(ALGraph *G)    
106. //输出邻接表G    
107. {    
108.     int i;    
109.     ArcNode *p;    
110.     for (i=0; i<G->n; i++)    
111.     {    
112.         p=G->adjlist[i].firstarc;    
113.         printf("%3d: ",i);    
114.         while (p!=NULL)    
115.         {    
116.             printf("-->%d/%d ",p->adjvex,p->info);    
117.             p=p->nextarc;    
118.         }    
119.         printf("\n");    
120.     }    
121. }    

[cpp]  view plain  copy

 

1. //3.在同一项目（project）中建立一个源文件(如main.cpp)，编制main函数，完成相关的测试工作。 例：  
2. #include <stdio.h>    
3. #include <malloc.h>    
4. #include "graph.h"    
5.     
6. void Prim(MGraph g,int v)    
7. {    
8.     int lowcost[MAXV];          //顶点i是否在U中    
9.     int min;    
10.     int closest[MAXV],i,j,k;    
11.     for (i=0; i<g.n; i++)           //给lowcost[]和closest[]置初值    
12.     {    
13.         lowcost[i]=g.edges[v][i];    
14.         closest[i]=v;    
15.     }    
16.     for (i=1; i<g.n; i++)           //找出n-1个顶点    
17.     {    
18.         min=INF;    
19.         for (j=0; j<g.n; j++)     //在(V-U)中找出离U最近的顶点k    
20.             if (lowcost[j]!=0 && lowcost[j]<min)    
21.             {    
22.                 min=lowcost[j];    
23.                 k=j;            //k记录最近顶点的编号    
24.             }    
25.         printf(" 边(%d,%d)权为:%d\n",closest[k],k,min);    
26.         lowcost[k]=0;           //标记k已经加入U    
27.         for (j=0; j<g.n; j++)       //修改数组lowcost和closest    
28.             if (g.edges[k][j]!=0 && g.edges[k][j]<lowcost[j])    
29.             {    
30.                 lowcost[j]=g.edges[k][j];    
31.                 closest[j]=k;    
32.             }    
33.     }    
34. }    
35.     
36. int main()    
37. {    
38.     MGraph g;    
39.     int A[6][6]=    
40.     {    
41.         {0,10,INF,INF,19,21},    
42.         {10,0,5,6,INF,11},    
43.         {INF,5,0,6,INF,INF},    
44.         {INF,6,6,0,18,14},    
45.         {19,INF,INF,18,0,33},    
46.         {21,11,INF,14,33,0}    
47.     };    
48.     ArrayToMat(A[0], 6, g);    
49.     printf("最小生成树构成:\n");    
50.     Prim(g,0);    
51.     return 0;    
52. }    

附：测试用图结构

运行结果：