利用c语言实现用队列求解迷宫问题的最短路径

小彤酱

利用c语言实现用队列求解迷宫问题的最短路径

陶远航

在C语言中，我们可以使用广度优先搜索（BFS）算法和队列数据结构来求解迷宫问题的最短路径。以下是一个简单的实现：

首先，我们需要定义一个队列和一个节点：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #define MAXSIZE 100
   
5. 
   
6. typedef struct {
   
7.     int x;
   
8.     int y;
   
9.     int step;
   
10. } Node;
    
11. 
    
12. typedef struct {
    
13.     Node data[MAXSIZE];
    
14.     int front;
    
15.     int rear;
    
16. } Queue;
    
17. 
    
18. Queue* initQueue() {
    
19.     Queue* q = (Queue*)malloc(sizeof(Queue));
    
20.     q->front = 0;
    
21.     q->rear = 0;
    
22.     return q;
    
23. }
    
24. 
    
25. void enqueue(Queue* q, Node node) {
    
26.     if ((q->rear + 1) % MAXSIZE == q->front) {
    
27.         return;
    
28.     }
    
29.     q->data[q->rear] = node;
    
30.     q->rear = (q->rear + 1) % MAXSIZE;
    
31. }
    
32. 
    
33. Node dequeue(Queue* q) {
    
34.     if (q->front == q->rear) {
    
35.         exit(0);
    
36.     }
    
37.     Node node = q->data[q->front];
    
38.     q->front = (q->front + 1) % MAXSIZE;
    
39.     return node;
    
40. }
    
41. 
    
42. int isEmpty(Queue* q) {
    
43.     return q->front == q->rear;
    
44. }
    

复制代码

然后，我们可以使用广度优先搜索（BFS）算法来找到迷宫的最短路径：

1. #define N 5
   
2. #define M 5
   
3. 
   
4. int maze[N][M] = {
   
5.     {0, 1, 0, 0, 0},
   
6.     {0, 1, 0, 1, 0},
   
7.     {0, 0, 0, 0, 0},
   
8.     {0, 1, 1, 1, 1},
   
9.     {0, 0, 0, 0, 0}
   
10. };
    
11. 
    
12. int visited[N][M] = {0};
    
13. 
    
14. int direction[4][2] = {
    
15.     {-1, 0}, // up
    
16.     {1, 0},  // down
    
17.     {0, -1}, // left
    
18.     {0, 1}   // right
    
19. };
    
20. 
    
21. void BFS(int x, int y) {
    
22.     Queue* q = initQueue();
    
23.     Node start = {x, y, 0};
    
24.     enqueue(q, start);
    
25.     visited[x][y] = 1;
    
26. 
    
27.     while (!isEmpty(q)) {
    
28.         Node cur = dequeue(q);
    
29.         if (cur.x == N - 1 && cur.y == M - 1) {
    
30.             printf("The shortest path is %d steps.\
    
31. ", cur.step);
    
32.             return;
    
33.         }
    
34. 
    
35.         for (int i = 0; i < 4; i++) {
    
36.             int newX = cur.x + direction[ i][0];
    
37.             int newY = cur.y + direction[ i][1];
    
38. 
    
39.             if (newX >= 0 && newX < N && newY >= 0 && newY < M && maze[newX][newY] == 0 && visited[newX][newY] == 0) {
    
40.                 Node next = {newX, newY, cur.step + 1};
    
41.                 enqueue(q, next);
    
42.                 visited[newX][newY] = 1;
    
43.             }
    
44.         }
    
45.     }
    
46. 
    
47.     printf("No path found.\
    
48. ");
    
49. }
    
50. 
    
51. int main() {
    
52.     BFS(0, 0);
    
53.     return 0;
    
54. }
    

复制代码

在这个代码中，我们首先定义了一个迷宫和一个访问数组。然后，我们使用广度优先搜索（BFS）算法来找到迷宫的最短路径。我们从起点开始，然后探索每个方向，如果新的位置是可达的（即不是墙壁，并且没有被访问过），我们就将其添加到队列中，并更新步数和访问数组。当我们到达终点时，我们就找到了最短路径。如果队列为空，那么迷宫没有解决方案。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

isdkz

这是一个经典的迷宫问题，可以使用广度优先搜索算法来解决。以下是使用队列实现的c语言代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #define ROW 10
   
5. #define COL 10
   
6. 
   
7. int maze[ROW][COL] = {
   
8.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
   
9.     {0, 1, 0, 1, 1, 1, 0, 0, 0, 0},
   
10.     {0, 1, 0, 0, 0, 1, 0, 0, 0, 0},
    
11.     {0, 1, 0, 1, 0, 1, 0, 0, 0, 0},
    
12.     {0, 1, 0, 1, 0, 1, 0, 0, 0, 0},
    
13.     {0, 1, 0, 1, 0, 1, 0, 0, 0, 0},
    
14.     {0, 1, 0, 1, 0, 1, 0, 0, 0, 0},
    
15.     {0, 1, 0, 1, 0, 1, 0, 0, 0, 0},
    
16.     {0, 1, 0, 1, 0, 1, 0, 0, 0, 0},
    
17.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    
18. }; // 迷宫地图
    
19. 
    
20. int visited[ROW][COL] = {0}; // 标记是否已经访问过
    
21. 
    
22. int dir[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}}; // 上下左右四个方向
    
23. 
    
24. typedef struct {
    
25.     int x;
    
26.     int y;
    
27.     int step;
    
28. } Node; // 队列中的节点
    
29. 
    
30. typedef struct {
    
31.     Node data[ROW * COL];
    
32.     int front;
    
33.     int rear;
    
34. } Queue; // 队列
    
35. 
    
36. Queue q;
    
37. 
    
38. void initQueue() {
    
39.     q.front = 0;
    
40.     q.rear = 0;
    
41. }
    
42. 
    
43. void enqueue(Node node) {
    
44.     q.data[q.rear++] = node;
    
45. }
    
46. 
    
47. Node dequeue() {
    
48.     return q.data[q.front++];
    
49. }
    
50. 
    
51. int isEmpty() {
    
52.     return q.front == q.rear;
    
53. }
    
54. 
    
55. int bfs(int startX, int startY, int endX, int endY) {
    
56.     initQueue();
    
57.     Node start = {startX, startY, 0};
    
58.     visited[startX][startY] = 1;
    
59.     enqueue(start);
    
60.     while (!isEmpty()) {
    
61.         Node cur = dequeue();
    
62.         if (cur.x == endX && cur.y == endY) {
    
63.             return cur.step;
    
64.         }
    
65.         for (int i = 0; i < 4; i++) {
    
66.             int nx = cur.x + dir[ i][0];
    
67.             int ny = cur.y + dir[ i][1];
    
68.             if (nx >= 0 && nx < ROW && ny >= 0 && ny < COL && !visited[nx][ny] && maze[nx][ny] == 0) {
    
69.                 visited[nx][ny] = 1;
    
70.                 Node next = {nx, ny, cur.step + 1};
    
71.                 enqueue(next);
    
72.             }
    
73.         }
    
74.     }
    
75.     return -1; // 无法到达终点
    
76. }
    
77. 
    
78. int main() {
    
79.     int startX = 1, startY = 1, endX = 8, endY = 8;
    
80.     int steps = bfs(startX, startY, endX, endY);
    
81.     printf("最短路径长度为：%d\n", steps);
    
82.     return 0;
    
83. }
    

复制代码

在上面的代码中，我们使用了一个队列来存储待访问的节点。首先将起点加入队列中，然后不断从队列中取出一个节点，遍历其四个相邻节点，如果相邻节点未被访问过且可通行，则加入队列中。当取出的节点为终点时，返回其步数即为最短路径长度。

Mike_python小

求解迷宫问题的最短路径需要使用广度优先搜索算法和队列数据结构来实现。下面是用C语言实现的代码示例：

2. #include <stdio.h>
3. #include <stdbool.h>
5. #define MAX_ROW 10
6. #define MAX_COL 10
8. // 迷宫地图的大小
9. int row, col;
11. // 迷宫地图
12. int maze[MAX_ROW][MAX_COL] = {
13.     {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
14.     {1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
15.     {1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
16.     {1, 0, 0, 0, 0, 1, 1, 0, 0, 1},
17.     {1, 0, 1, 1, 1, 0, 0, 0, 0, 1},
18.     {1, 0, 0, 0, 1, 0, 0, 1, 0, 1},
19.     {1, 0, 1, 0, 0, 0, 0, 1, 0, 1},
20.     {1, 0, 1, 1, 1, 0, 0, 1, 0, 1},
21.     {1, 1, 0, 0, 0, 0, 0, 0, 0, 1},
22.     {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
23. };
25. // 定义坐标结构体
26. typedef struct {
27.     int x;
28.     int y;
29. } Coordinate;
31. // 定义队列结构体
32. typedef struct {
33.     Coordinate data[MAX_ROW * MAX_COL];
34.     int front;
35.     int rear;
36. } Queue;
38. // 初始化队列
39. void initQueue(Queue *q) {
40.     q->front = 0;
41.     q->rear = 0;
42. }
44. // 判断队列是否为空
45. bool isEmpty(Queue *q) {
46.     return q->front == q->rear;
47. }
49. // 入队
50. void enqueue(Queue *q, Coordinate elem) {
51.     q->data[q->rear] = elem;
52.     q->rear++;
53. }
55. // 出队
56. Coordinate dequeue(Queue *q) {
57.     Coordinate elem = q->data[q->front];
58.     q->front++;
59.     return elem;
60. }
62. // 广度优先搜索求解迷宫最短路径
63. bool breadthFirstSearch(Coordinate start, Coordinate end) {
64.     Queue queue;
65.     bool visited[MAX_ROW][MAX_COL] = {false}; // 记录每个位置是否已经访问过
67.     initQueue(&queue);
68.     enqueue(&queue, start);
69.     visited[start.x][start.y] = true;
71.     int offsetX[] = {-1, 1, 0, 0}; // 上下左右的偏移量
72.     int offsetY[] = {0, 0, -1, 1};
74.     while (!isEmpty(&queue)) {
75.         Coordinate current = dequeue(&queue);
77.         if (current.x == end.x && current.y == end.y) {
78.             return true; // 找到了终点
79.         }
81.         // 遍历上下左右四个方向
82.         for (int i = 0; i < 4; i++) {
83.             int nextX = current.x + offsetX[i];
84.             int nextY = current.y + offsetY[i];
86.             // 判断是否可以移动到nextX, nextY，并且没有访问过
87.             if (nextX >= 0 && nextX < row && nextY >= 0 && nextY < col &&
88.                 maze[nextX][nextY] == 0 && !visited[nextX][nextY]) {
89.                 Coordinate next = {nextX, nextY};
90.                 enqueue(&queue, next);
91.                 visited[nextX][nextY] = true;
92.             }
93.         }
94.     }
96.     return false; // 没有找到终点
97. }
99. int main() {
100.     row = 10;
101.     col = 10;
103.     Coordinate start = {1, 1};
104.     Coordinate end = {8, 8};
106.     bool found = breadthFirstSearch(start, end);
108.     if (found) {
109.         printf("找到了最短路径！\n");
110.     } else {
111.         printf("无法找到最短路径！\n");
112.     }
114.     return 0;
115. }

复制代码

以上代码中，使用 Coordinate 结构体表示迷宫中的坐标，Queue 结构体表示队列。initQueue 函数用于初始化队列，isEmpty 函数用于判断队列是否为空，enqueue 函数用于入队，dequeue 函数用于出队。

breadthFirstSearch 函数使用广度优先搜索算法来求解迷宫的最短路径。首先初始化队列，并将起始坐标入队，并标记为已访问。然后进行循环，直到队列为空。在每一步循环中，出队一个坐标，判断是否为终点坐标，如果是则返回 true 表示找到了最短路径。否则，遍历当前位置上下左右四个方向，判断是否可以移动到相邻位置，并且没有访问过，如果满足条件，则将相邻位置入队，并标记为已访问。循环结束后，如果没有找到终点，则返回 false。

最后，在 main 函数中定义迷宫的大小、起点和终点，调用 breadthFirstSearch 函数进行求解，并输出结果。

希望这样的回答能帮助到你，如果还有其他问题，请继续提问。

球一个最佳答案谢谢啦！这对我非常重要！