图的基本算法实现（邻接矩阵与邻接表两种方法）

一、无向图

 

1 无向图——邻接矩阵

测试环境：VS2008

 

[cpp:showcolumns]  view plain copy print ?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. #include "stdafx.h"  
2. #include <stdlib.h>  
3. #include <malloc.h>  
4. #define MAX_VEX 20  
5. #define INFINITY 65535  
6. int *visited;  
7. struct _node  
8. {  
9.     int vex_num;  
10.     struct _node *next;  
11. };  
12. typedef struct _node node, *pnode;  
13. struct _graph  
14. {  
15.     char *vexs;  
16.     int arcs[MAX_VEX][MAX_VEX];  
17.     int vexnum, arcnum;  
18. };  
19. typedef struct _graph graph, *pgraph;  
20. int locate(graph g, char ch)  
21. {  
22.     int i;  
23.     for(i=1; i<=g.vexnum; i++)  
24.         if(g.vexs[i]==ch)  
25.             return i;  
26.     return -1;  
27. }  
28. graph create_graph()  
29. {  
30.     int i, j, w, p1, p2;  
31.     char ch1, ch2;  
32.     graph g;  
33.     printf("Enter vexnum arcnum: ");  
34.     scanf("%d %d", &g.vexnum, &g.arcnum);  
35.     getchar();  
36.     for(i=1; i<=g.vexnum; i++)  
37.         for(j=1; j<g.vexnum; j++)  
38.             g.arcs[i][j]=INFINITY;  
39.     g.vexs=(char *)malloc(sizeof(char));  
40.     printf("Enter %d vexnum.../n", g.vexnum);  
41.     for(i=1; i<=g.vexnum; i++)  
42.     {  
43.         printf("vex %d: ", i);  
44.         scanf("%c", &g.vexs[i]);  
45.         getchar();  
46.     }  
47.     printf("Enter %d arcnum.../n", g.arcnum);  
48.     for(i=1; i<=g.arcnum; i++)  
49.     {  
50.         printf("arc %d: ", i);  
51.         scanf("%c %c %d", &ch1, &ch2, &w);  
52.         getchar();  
53.         p1=locate(g, ch1);  
54.         p2=locate(g, ch2);  
55.         g.arcs[p1][p2]=g.arcs[p2][p1]=w;  
56.     }  
57.     return g;  
58. }  
59. int firstvex_graph(graph g, int i)  
60. {  
61.     int k;  
62.     if(i>=1 && i<=g.vexnum)  
63.         for(k=1; k<=g.vexnum; k++)  
64.             if(g.arcs[i][k]!=INFINITY)  
65.                 return k;  
66.     return -1;  
67. }  
68. int nextvex_graph(graph g, int i, int j)  
69. {  
70.     int k;  
71.     if(i>=1 && i<=g.vexnum && j>=1 && j<=g.vexnum)  
72.         for(k=j+1; k<=g.vexnum; k++)  
73.             if(g.arcs[i][k]!=INFINITY)  
74.                 return k;  
75.     return -1;  
76. }  
77. void dfs(graph g, int i)  
78. {  
79.     int k, j;  
80.     if(!visited[i])  
81.     {  
82.         visited[i]=1;  
83.         printf("%3c", g.vexs[i]);  
84.         for(j=firstvex_graph(g, i); j>=1; j=nextvex_graph(g, i, j))  
85.             if(!visited[j])  
86.                 dfs(g, j);  
87.     }  
88. }  
89. void dfs_graph(graph g)  
90. {  
91.     int i;  
92.     visited=(int *)malloc((g.vexnum+1)*sizeof(int));  
93.     for(i=1; i<=g.vexnum; i++)  
94.         visited[i]=0;  
95.     for(i=1; i<g.vexnum; i++)  
96.         if(!visited[i])  
97.             dfs(g, i);  
98. }  
99. int _tmain(int argc, _TCHAR* argv[])  
100. {  
101.     graph g;  
102.     g=create_graph();  
103.     printf("DFS: ");  
104.     dfs_graph(g);  
105.     printf("/n");  
106.     return 0;  
107. }  

 

运行结果：

       

==========================================================

2 无向图—— 邻接表

测试环境：VS2008

 

[cpp:showcolumns]  view plain copy print ?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. #include "stdafx.h"  
2. #include <stdlib.h>  
3. #include <malloc.h>  
4. #define MAX_VEX 20  
5. int *visited;  
6. typedef struct _ArcNode  
7. {  
8.     int ivex; /* next ivex */  
9.     struct _ArcNode *nextarc; /* next node */  
10.     int *info; /* arc weight */  
11. };  
12. typedef struct _ArcNode ArcNode, *pArcNode;  
13. struct _VNode  
14. {  
15.     char adjvex; /* note vex */  
16.     ArcNode *firstarc;  
17. };  
18. typedef struct _VNode VNode;  
19. struct _ALGraph  
20. {  
21.     VNode AdjList[MAX_VEX];  
22.     int vexnum, arcnum;  
23.     int kink;  
24. };  
25. typedef struct _ALGraph ALGraph;  
26. int locate(ALGraph g, char ch)  
27. {  
28.     int i;  
29.     for(i=1; i<=g.vexnum; i++)  
30.         if(g.AdjList[i].adjvex==ch)  
31.             return i;  
32.     return -1;  
33. }  
34. ALGraph create_graph()  
35. {  
36.     int i, j, w, p1, p2;  
37.     char ch1, ch2;  
38.     pArcNode pnode, pnode1, pnode2;  
39.     ALGraph g;  
40.     printf("Enter vexnum arcnum: ");  
41.     scanf("%d %d", &g.vexnum, &g.arcnum);  
42.     getchar();  
43.       
44.     printf("Enter %d vexnum.../n", g.vexnum);  
45.     for(i=1; i<=g.vexnum; i++)  
46.     {  
47.         printf("vex %d: ", i);  
48.         scanf("%c", &g.AdjList[i].adjvex);  
49.         getchar();  
50.         g.AdjList[i].firstarc=NULL;  
51.     }  
52.     printf("Enter arc.../n");  
53.     for(i=1; i<=g.arcnum; i++)  
54.     {  
55.         printf("arc %d: ", i);  
56.         scanf("%c %c", &ch1, &ch2);  
57.         getchar();  
58.         p1=locate(g, ch1);  
59.         p2=locate(g, ch2);  
60.         pnode1=(pArcNode)malloc(sizeof(ArcNode));  
61.         pnode2=(pArcNode)malloc(sizeof(ArcNode));  
62.         pnode1->ivex=p2; /* next ivex */  
63.         pnode1->nextarc=g.AdjList[p1].firstarc;  
64.         g.AdjList[p1].firstarc=pnode1;  
65.         pnode2->ivex=p1; /* next ivex */  
66.         pnode2->nextarc=g.AdjList[p2].firstarc;  
67.         g.AdjList[p2].firstarc=pnode2;  
68.     }  
69.     return g;  
70. }  
71. int firstvex_graph(ALGraph g, int i)  
72. {  
73.     int k;  
74.     if(i>=1 && i<=g.vexnum)     
75.         if(g.AdjList[i].firstarc)  
76.             return g.AdjList[i].firstarc->ivex;  
77.     return -1;  
78. }  
79. int nextvex_graph(ALGraph g, int i, int k)  
80. {  
81.     pArcNode pnode;  
82.     if(i>=1 && i<=g.vexnum && k>=1 && k<=g.vexnum)  
83.     {  
84.         pnode=g.AdjList[i].firstarc;  
85.         while(pnode->nextarc)  
86.         {  
87.             k=pnode->nextarc->ivex;  
88.             if(!visited[k])  
89.                 return k;  
90.             else  
91.                 pnode=pnode->nextarc;  
92.         }  
93.     }  
94.     return -1;  
95. }  
96. void dfs(ALGraph g, int i)  
97. {  
98.     int k;  
99.     if(!visited[i])  
100.     {  
101.         visited[i]=1;  
102.         printf("%c", g.AdjList[i].adjvex);  
103.         for(k=firstvex_graph(g, i); k>=1; k=nextvex_graph(g, i, k))  
104.             if(!visited[k])  
105.                 dfs(g, k);  
106.     }  
107. }  
108. void dfs_graph(ALGraph g)  
109. {  
110.     int i;  
111.     visited=(int *)malloc((g.vexnum+1)*sizeof(int));  
112.     for(i=1; i<=g.vexnum; i++)  
113.         visited[i]=0;  
114.     for(i=1; i<=g.vexnum; i++)  
115.         if(!visited[i])  
116.             dfs(g, i);  
117. }  
118. int _tmain(int argc, _TCHAR* argv[])  
119. {  
120.     ALGraph g;  
121.     g=create_graph();  
122.     dfs_graph(g);  
123.     printf("/n");  
124.     return 0;  
125. }  

 

运行结果：

      

 

原谅链接：http://blog.csdn.net/Sunboy_2050/article/details/5683488

转载于:https://www.cnblogs.com/10jschen/archive/2012/08/15/2639627.html