图的实现和图的广度遍历 Gragh's BFS

图的实现方法有2种，在之前的一篇博文图的深度遍历中有介绍。在同样的2种图的存储方式的基础上，可以进行图的广度遍历。

图的邻接矩阵法，依然是申请完全连续的空间。通过二维数组空间来存储和访问图中每个边的存在性（或权值）。

int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);

edge是一个数组指针。

图的邻接表法，是利用单链式结构（邻接表）存储每个点的可直达节点。并申请连续的空间存储这些邻接表的首结点地址（如果该点没有可直达节点，那首结点位置就为NULL）。

typedef struct edge{
int vertex;
struct edge* next;
}st_edge;

st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);

在DFS中，访问的顺序是受到递归逻辑控制的。而BFS中，我们需要借助队列来控制访问的顺序。在另一篇博文中，实现的是线性物理结构的队列。这一次使用链式物理结构来实现队列。我们使用双向链表来存储队列，这样的好处是表头可以快速删除节点，表尾可以快速插入节点。

[cpp]  view plain copy

1. typedef struct  qElement{  
2.     int value;  
3.     struct  qElement* pre;  
4.     struct  qElement* next;  
5. }st_qElement;  
6.   
7. st_qElement* front = NULL;  
8. st_qElement* rear = NULL;  

对队列的操作：

1. 入队：将一个新元素加入队列（插在队尾）

2. 出队：将队尾元素删除

[cpp]  view plain copy

1. void putQueue(int vertex)  
2. {  
3.     st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
4.     qe->value = vertex;  
5.     qe->next = NULL;  
6.     qe->pre = NULL;  
7.   
8.     if(front == NULL || rear == NULL)  
9.         front = rear = qe;  
10.     else{  
11.         rear->next = qe;  
12.         qe->pre = rear;  
13.         rear = qe;  
14.     }  
15. }  
16.   
17. int* getQueue()  
18. {  
19.     if(front ==NULL || rear == NULL)  
20.         return NULL;  
21.     else{  
22.         int* res = (int*)malloc(sizeof(int));  
23.         *res = front->value;  
24.         st_qElement* p = front;  
25.         front = front->next;  
26.         if(front == NULL)  
27.             rear = front;  
28.         else  
29.         {  
30.             front->pre = NULL;  
31.         }  
32.         free(p);  
33.         p = NULL;  
34.         return res;  
35.     }  
36. }  

怎么在BFS中使用队列？

BFS的遍历顺序是按层序。每一层的访问顺序都是由上一层访问的顺序决定好的，这个顺序是存储在队列中。

当访问某一个节点时，就为下一层访问其所有邻接节点做好准备，即将其所有邻接节点依次入队。

那么，整个BFS的访问就是依次从队列中取队头元素，访问它。（当然，首个节点是主动放进队中的。）

邻接矩阵的BFS实现：

[cpp]  view plain copy

1. void bfs(int (*edge)[VERTEXNUM], int* vetexStatusArr)  
2. {  
3.     printf("BFS: ");  
4.     int i;  
5.     for(i=0;i<VERTEXNUM;i++)  
6.         bfscore(edge, i, vetexStatusArr);  
7.     printf("\n");  
8. }  
9.   
10. void bfscore(int (*edge)[VERTEXNUM], int i, int* vetexStatusArr)  
11. {  
12.     putQueue(i);  
13.     int* qeValue = NULL;  
14.     while((qeValue = getQueue()) != NULL)  
15.     {  
16.         if(vetexStatusArr[*qeValue] == 0)  
17.         {  
18.             printf("%d ", *qeValue);  
19.             vetexStatusArr[*qeValue] = 1;  
20.   
21.             //把与点vertex邻接的点都加进队列  
22.             for(int k=0;k<VERTEXNUM;k++)  
23.                 if(edge[*qeValue][k]==1)  
24.                     putQueue(k);  
25.         }  
26.         free(qeValue);  
27.         qeValue = NULL;  
28.     }  
29. }  

邻接表的实现BFS实现：

[cpp]  view plain copy

1. void bfscore(st_edge** edge, int i, int *vertexStatusArr)  
2. {  
3.     putQueue(i);  
4.     int *qeValue = NULL;  
5.     while((qeValue = getQueue()) != NULL)  
6.     {  
7.         if(vertexStatusArr[*qeValue] == 0)  
8.         {  
9.             vertexStatusArr[*qeValue] = 1;  
10.             printf("%d ", *qeValue);  
11.             st_edge *p = *(edge + *qeValue);  
12.             while(p != NULL)  
13.             {  
14.                 putQueue(p->vertex);  
15.                 p = p->next;  
16.             }  
17.         }  
18.         free(qeValue);  
19.         qeValue = NULL;  
20.     }  
21. }  
22.   
23. void bfs(st_edge** edge, int* vertexStatusArr)  
24. {  
25.     printf("BFS: ");  
26.     int i;  
27.     for(i=0;i<VERTEXNUM;i++)  
28.         bfscore(edge, i, vertexStatusArr);  
29.     printf("\n");  
30. }  

邻接矩阵存储方式的BFS完整代码：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <malloc.h>  
3. #define VERTEXNUM 5  
4.   
5. //双向链表存储的队列  
6. typedef struct  qElement{  
7.     int value;  
8.     struct  qElement* pre;  
9.     struct  qElement* next;  
10. }st_qElement;  
11.   
12. st_qElement* front = NULL;  
13. st_qElement* rear = NULL;  
14.   
15. void putQueue(int vertex);  
16. int* getQueue();  
17.   
18. void createGraph(int (*edge)[VERTEXNUM], int start, int end);  
19. void display(int (*edge)[VERTEXNUM]);  
20.   
21. void bfs(int (*edge)[VERTEXNUM],int i,int* vetexStatusArr);  
22. void bfscore(int (*edge)[VERTEXNUM], int i, int* vetexStatusArr);  
23.   
24.   
25. void putQueue(int vertex)  
26. {  
27.     st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
28.     qe->value = vertex;  
29.     qe->next = NULL;  
30.     qe->pre = NULL;  
31.   
32.     if(front == NULL || rear == NULL)  
33.         front = rear = qe;  
34.     else{  
35.         rear->next = qe;  
36.         qe->pre = rear;  
37.         rear = qe;  
38.     }  
39. }  
40.   
41. int* getQueue()  
42. {  
43.     if(front ==NULL || rear == NULL)  
44.         return NULL;  
45.     else{  
46.         int* res = (int*)malloc(sizeof(int));  
47.         *res = front->value;  
48.         st_qElement* p = front;  
49.         front = front->next;  
50.         if(front == NULL)  
51.             rear = front;  
52.         else  
53.         {  
54.             front->pre = NULL;  
55.         }  
56.         free(p);  
57.         p = NULL;  
58.         return res;  
59.     }  
60. }  
61.   
62. void createGraph(int (*edge)[VERTEXNUM], int start, int end)  
63. {  
64.     edge[start][end] = 1;  
65. }  
66.   
67. void display(int (*edge)[VERTEXNUM])  
68. {  
69.     int i,j;  
70.     for(i=0;i<VERTEXNUM;i++)  
71.     {  
72.         for(j=0;j<VERTEXNUM;j++)  
73.             printf("%d ", edge[i][j]);  
74.   
75.         printf("\n");  
76.     }  
77. }  
78.   
79. void bfs(int (*edge)[VERTEXNUM], int* vetexStatusArr)  
80. {  
81.     printf("BFS: ");  
82.     int i;  
83.     for(i=0;i<VERTEXNUM;i++)  
84.         bfscore(edge, i, vetexStatusArr);  
85.     printf("\n");  
86. }  
87.   
88. void bfscore(int (*edge)[VERTEXNUM], int i, int* vetexStatusArr)  
89. {  
90.     putQueue(i);  
91.     int* qeValue = NULL;  
92.     while((qeValue = getQueue()) != NULL)  
93.     {  
94.         if(vetexStatusArr[*qeValue] == 0)  
95.         {  
96.             printf("%d ", *qeValue);  
97.             vetexStatusArr[*qeValue] = 1;  
98.   
99.             //把与点vertex邻接的点都加进队列  
100.             for(int k=0;k<VERTEXNUM;k++)  
101.                 if(edge[*qeValue][k]==1)  
102.                     putQueue(k);  
103.         }  
104.         free(qeValue);  
105.         qeValue = NULL;  
106.     }  
107. }  
108.   
109. int main()  
110. {  
111.     int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);  
112.     int i, j;  
113.     for(i=0;i<VERTEXNUM;i++)  
114.         for(j=0;j<VERTEXNUM;j++)  
115.             edge[i][j] = 0;  
116.   
117.     int *vetexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
118.     for(i=0;i<VERTEXNUM;i++)  
119.         vetexStatusArr[i] = 0;  
120.   
121.     createGraph(edge, 0, 3);  
122.     createGraph(edge, 0, 4);  
123.     createGraph(edge, 3, 1);  
124.     createGraph(edge, 3, 2);  
125.     createGraph(edge, 4, 1);  
126.     display(edge);  
127.   
128.     bfs(edge, vetexStatusArr);  
129.     free(edge);  
130.     return 1;  
131. }  

邻接表存储方式的BFS完整代码：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <malloc.h>  
3. #define VERTEXNUM 5  
4.   
5. typedef struct edge{  
6.     int vertex;  
7.     struct edge* next;  
8. }st_edge;  
9.   
10. typedef struct qElement{  
11.     int value;  
12.     struct qElement* pre;  
13.     struct qElement* next;  
14. }st_qElement;  
15.   
16. st_qElement* front = NULL;  
17. st_qElement* rear = NULL;  
18.   
19. void putQueue(int vertex)  
20. {  
21.     st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
22.     qe->value = vertex;  
23.     qe->next = NULL;  
24.     qe->pre = NULL;  
25.     if(front == NULL || rear == NULL)  
26.         front = rear = qe;  
27.     else  
28.     {  
29.         rear->next = qe;  
30.         qe->pre = rear;  
31.         rear = qe;  
32.     }  
33. }  
34.   
35. int* getQueue()  
36. {  
37.     if(front == NULL || rear == NULL)  
38.         return NULL;  
39.     else  
40.     {  
41.         int *res = (int*)malloc(sizeof(int));  
42.         *res = front->value;  
43.   
44.         st_qElement* p = front;  
45.         front = front->next;  
46.         if(front == NULL)  
47.             rear = front;  
48.         else  
49.             front->pre = NULL;  
50.         free(p);  
51.         p = NULL;  
52.         return res;  
53.     }  
54. }  
55.   
56. void display(st_edge** edge)  
57. {  
58.     int i;  
59.     st_edge* p;  
60.     for(i=0;i<VERTEXNUM;i++)  
61.     {  
62.         printf("%d: ", i);  
63.         p = *(edge+i);  
64.         while(p != NULL)  
65.         {  
66.             printf("%d ", p->vertex);  
67.             p = p->next;  
68.         }  
69.         printf("\n");  
70.     }  
71. }  
72.   
73. void createGraph(st_edge** edge, int start, int end)  
74. {  
75.     st_edge* newedge = (st_edge*)malloc(sizeof(st_edge));  
76.     newedge->vertex = end;  
77.     newedge->next = NULL;  
78.     edge = edge + start;  
79.     while(*edge != NULL)  
80.         edge = &((*edge)->next);  
81.     *edge = newedge;  
82. }  
83.   
84.   
85. void bfscore(st_edge** edge, int i, int *vertexStatusArr)  
86. {  
87.     putQueue(i);  
88.     int *qeValue = NULL;  
89.     while((qeValue = getQueue()) != NULL)  
90.     {  
91.         if(vertexStatusArr[*qeValue] == 0)  
92.         {  
93.             vertexStatusArr[*qeValue] = 1;  
94.             printf("%d ", *qeValue);  
95.             st_edge *p = *(edge + *qeValue);  
96.             while(p != NULL)  
97.             {  
98.                 putQueue(p->vertex);  
99.                 p = p->next;  
100.             }  
101.         }  
102.         free(qeValue);  
103.         qeValue = NULL;  
104.     }  
105. }  
106.   
107. void bfs(st_edge** edge, int* vertexStatusArr)  
108. {  
109.     printf("BFS: ");  
110.     int i;  
111.     for(i=0;i<VERTEXNUM;i++)  
112.         bfscore(edge, i, vertexStatusArr);  
113.     printf("\n");  
114. }  
115.   
116. int main()  
117. {  
118.     st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);  
119.     int i;  
120.     for(i=0;i<VERTEXNUM;i++)  
121.         edge[i] = NULL;  
122.   
123.     int *vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
124.     for(i=0;i<VERTEXNUM;i++)  
125.         vertexStatusArr[i] = 0;  
126.   
127.     createGraph(edge, 0 ,3);  
128.     createGraph(edge, 0, 4);  
129.     createGraph(edge, 3, 1);  
130.     createGraph(edge, 3, 2);  
131.     createGraph(edge, 4, 1);  
132.   
133.     display(edge);  
134.     bfs(edge, vertexStatusArr);  
135.   
136.     return 1;  
137. }