广度优先搜索

广度优先是一种步步为营的策略，每次都从各个方向探索一步，将前线推进一步，图中的虚线就表示这个前线，队列中的元素总是由前线的点组成的，可见正是队列先进先出的性质使这个算法具有了广度优先的特点。广度优先搜索还有一个特点是可以找到从起点到终点的最短路径，而深度优先搜索找到的不一定是最短路径。

[csharp]  view plain  copy

 print ?

1. #include <stdio.h>  
2. #define MAX_ROW 5  
3. #define MAX_COL 5  
4. struct point { int row, col, predecessor; } queue[512];  
5. int head = 0, tail = 0;  
6. void enqueue(struct point p)  
7. {  
8.     queue[tail++] = p;  
9. }  
10. struct point dequeue(void)  
11. {  
12.     return queue[head++];  
13. }  
14. int is_empty(void)  
15. {  
16.     return head == tail;  
17. }  
18. int maze[MAX_ROW][MAX_COL] = {  
19.     0, 1, 0, 0, 0,  
20.     0, 1, 0, 1, 0,  
21.     0, 0, 0, 0, 0,  
22.     0, 1, 1, 1, 0,  
23.     0, 0, 0, 1, 0,  
24. };  
25. void print_maze(void)  
26. {  
27.     int i, j;  
28.     for (i = 0; i < MAX_ROW; i++) {  
29.         for (j = 0; j < MAX_COL; j++)  
30.         printf("%d ", maze[i][j]);  
31.         putchar('\n');  
32.     }  
33.     printf("*********\n");  
34. }  
35.   
36. void visit(int row, int col)  
37. {  
38.     struct point visit_point = { row, col, head-1 };  
39.     maze[row][col] = 2;  
40.     enqueue(visit_point);  
41. }  
42. int main(void)  
43. {  
44.     struct point p = { 0, 0, -1 };  
45.     maze[p.row][p.col] = 2;  
46.     enqueue(p);  
47.     while (!is_empty()) {  
48.         p = dequeue();  
49.         if (p.row == MAX_ROW - 1 /* goal */  
50.         && p.col == MAX_COL - 1)  
51.         break;  
52.         if (p.col+1 < MAX_COL /* right */  
53.         && maze[p.row][p.col+1] == 0)  
54.         visit(p.row, p.col+1);  
55.         if (p.row+1 < MAX_ROW /* down */  
56.         && maze[p.row+1][p.col] == 0)  
57.         visit(p.row+1, p.col);  
58.         if (p.col-1 >= 0 /* left */  
59.         && maze[p.row][p.col-1] == 0)  
60.         visit(p.row, p.col-1);  
61.         if (p.row-1 >= 0 /* up */  
62.         && maze[p.row-1][p.col] == 0)  
63.         visit(p.row-1, p.col);  
64.         print_maze();  
65.     }  
66.     if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1)  
67.     {  
68.         printf("(%d, %d)\n", p.row, p.col);  
69.         while (p.predecessor != -1) {  
70.             p = queue[p.predecessor];  
71.             printf("(%d, %d)\n", p.row, p.col);  
72.         }  
73.     } else  
74.     printf("No path!\n");  
75.     return 0;  
76. }