第十一周项目实践2 用邻接表存储的图来实现基本应用

1. #ifndef GRAPH_H_INCLUDED  
2. #define GRAPH_H_INCLUDED  
3.   
4. #define MAXV 100                //最大顶点个数  
5. #define INF 32767       //INF表示∞  
6. typedef int InfoType;  
7.   
8. //以下定义邻接矩阵类型  
9. typedef struct  
10. {  
11.     int no;                     //顶点编号  
12.     InfoType info;              //顶点其他信息，在此存放带权图权值  
13. } VertexType;                   //顶点类型  
14.   
15. typedef struct                  //图的定义  
16. {  
17.     int edges[MAXV][MAXV];      //邻接矩阵  
18.     int n,e;                    //顶点数，弧数  
19.     VertexType vexs[MAXV];      //存放顶点信息  
20. } MGraph;                       //图的邻接矩阵类型  
21. //以下定义邻接表类型  
22. typedef struct ANode            //弧的结点结构类型  
23. {  
24.     int adjvex;                 //该弧的终点位置  
25.     struct ANode *nextarc;      //指向下一条弧的指针  
26.     InfoType info;              //该弧的相关信息,这里用于存放权值  
27. } ArcNode;  
28.   
29. typedef int Vertex;  
30.   
31. typedef struct Vnode            //邻接表头结点的类型  
32. {  
33.     Vertex data;                //顶点信息  
34.     int count;                  //存放顶点入度,只在拓扑排序中用  
35.     ArcNode *firstarc;          //指向第一条弧  
36. } VNode;  
37.   
38. typedef VNode AdjList[MAXV];    //AdjList是邻接表类型  
39.   
40. typedef struct  
41. {  
42.     AdjList adjlist;            //邻接表  
43.     int n,e;                    //图中顶点数n和边数e  
44. } ALGraph;                      //图的邻接表类型    void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表  
45. #endif // GRAPH_H_INCLUDED  
46. graph.cpp  
47.   
48. #include <stdio.h>  
49. #include <malloc.h>  
50. #include "graph.h"  
51. //功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图  
52. //参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）  
53. //      n - 矩阵的阶数  
54. //      g - 要构造出来的邻接矩阵数据结构  
55. void ArrayToList(int *Arr, int n, ALGraph *&G)  
56. {  
57.     int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数  
58.     ArcNode *p;  
59.     G=(ALGraph *)malloc(sizeof(ALGraph));  
60.     G->n=n;  
61.     for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值  
62.         G->adjlist[i].firstarc=NULL;  
63.     for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素  
64.         for (j=n-1; j>=0; j--)  
65.             if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]=Arr[i][j]（n是有多少列）  
66.             {  
67.                 p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p  
68.                 p->adjvex=j;  
69.                 p->info=Arr[i*n+j];  
70.                 p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p,和链表的操作一样  
71.                 G->adjlist[i].firstarc=p;  
72.             }  
73.     G->e=count;  
74. }  
75. main.cpp  
76. #include <stdio.h>  
77. #include <malloc.h>  
78. #include "graph.h"  
79. //返回图G中编号为v的顶点的出度  
80. int OutDegree(ALGraph *G,int v)  
81. {  
82.     ArcNode *p;  
83.     int n=0;  
84.     p=G->adjlist[v].firstarc;  
85.     while (p!=NULL)  
86.     {  
87.         n++;  
88.         p=p->nextarc;  
89.     }  
90.     return n;  
91. }  
92. //输出图G中每个顶点的出度  
93. void OutDs(ALGraph *G)  
94. {  
95.     int i;  
96.     for (i=0; i<G->n; i++)  
97.         printf("  顶点%d:%d\n",i,OutDegree(G,i));  
98. }  
99. //输出图G中出度最大的一个顶点  
100. void OutMaxDs(ALGraph *G)  
101. {  
102.     int maxv=0,maxds=0,i,x;  
103.     for (i=0; i<G->n; i++)  
104.     {  
105.         x=OutDegree(G,i);  
106.         if (x>maxds)  
107.         {  
108.             maxds=x;  
109.             maxv=i;  
110.         }  
111.     }  
112.     printf("顶点%d，出度=%d\n",maxv,maxds);  
113. }  
114. //输出图G中出度为0的顶点数  
115. void ZeroDs(ALGraph *G)  
116. {  
117.     int i,x;  
118.     for (i=0; i<G->n; i++)  
119.     {  
120.         x=OutDegree(G,i);  
121.         if (x==0)  
122.             printf("%2d",i);  
123.     }  
124.     printf("\n");  
125. }  
126. //返回图G中是否存在边<i,j>  
127. bool Arc(ALGraph *G, int i,int j)  
128. {  
129.     ArcNode *p;  
130.     bool found = false;  
131.     p=G->adjlist[i].firstarc;  
132.     while (p!=NULL)  
133.     {  
134.         if(p->adjvex==j)  
135.         {  
136.             found = true;  
137.             break;  
138.         }  
139.         p=p->nextarc;  
140.     }  
141.     return found;  
142. }  
143. int main()  
144. {  
145.     ALGraph *G;  
146.     int A[7][7]=  
147.     {  
148.         {0,1,1,1,0,0,0},  
149.         {0,0,0,0,1,0,0},  
150.         {0,0,0,0,1,1,0},  
151.         {0,0,0,0,0,0,1},  
152.         {0,0,0,0,0,0,0},  
153.         {0,0,0,1,1,0,1},  
154.         {0,1,0,0,0,0,0}  
155.     };  
156.     ArrayToList(A[0], 7, G);//建立邻接矩阵结构  
157.     printf("(1)各顶点出度:\n");  
158.     OutDs(G);  
159.     printf("(2)最大出度的顶点信息:");  
160.     OutMaxDs(G);  
161.     printf("(3)出度为0的顶点:");  
162.     ZeroDs(G);  
163.     printf("(4)边<2,6>存在吗？");  
164.     if(Arc(G,2,6))  
165.         printf("是\n");  
166.     else  
167.         printf("否\n");  
168.     printf("\n");  
169.     return 0;  
170. }