迷宫问题广度优先搜索c语言

好的，您需要一个迷宫问题的广度优先搜索的 C 语言实现，下面是一个简单的实现代码，仅供参考：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define ROW 5
#define COL 5

int maze[ROW][COL] = {
    {0, 1, 0, 0, 0},
    {0, 1, 0, 1, 0},
    {0, 0, 0, 0, 0},
    {0, 1, 1, 1, 0},
    {0, 0, 0, 1, 0}
};

bool visited[ROW][COL];

typedef struct {
    int x;
    int y;
    int prev;
} Point;

Point queue[ROW * COL];
int front = -1, rear = -1;

void enqueue(Point p) {
    if (front == -1) {
        front++;
    }
    queue[++rear] = p;
}

Point dequeue() {
    if (front > rear) {
        printf("Queue is empty!");
        exit(1);
    }
    return queue[front++];
}

bool is_valid(int x, int y) {
    if (x < 0 || x >= ROW || y < 0 || y >= COL) {
        return false;
    }
    if (maze[x][y] == 1 || visited[x][y]) {
        return false;
    }
    return true;
}

void print_path(Point p) {
    if (p.prev == -1) {
        printf("(%d, %d)", p.x, p.y);
        return;
    }
    print_path(queue[p.prev]);
    printf(" -> (%d, %d)", p.x, p.y);
}

void bfs(int x, int y) {
    visited[x][y] = true;
    Point start = {x, y, -1};
    enqueue(start);
    while (front <= rear) {
        Point curr = dequeue();
        if (curr.x == ROW - 1 && curr.y == COL - 1) {
            print_path(curr);
            return;
        }
        int x_dir[] = {-1, 0, 1, 0};
        int y_dir[] = {0, 1, 0, -1};
        for (int i = 0; i < 4; i++) {
            int next_x = curr.x + x_dir[i];
            int next_y = curr.y + y_dir[i];
            if (is_valid(next_x, next_y)) {
                visited[next_x][next_y] = true;
                Point next = {next_x, next_y, front - 1};
                enqueue(next);
            }
        }
    }
    printf("No path found!");
}

int main() {
    bfs(0, 0);
    return 0;
}

该代码中定义了一个 5x5 的迷宫，其中 0 表示可以通过，1 表示不能通过。首先将起点加入队列，然后每次从队列中取出一个点，判断是否到达终点，如果没有到达，则将其相邻的合法点加入队列，并标记为已访问，同时记录它的前一个点。最后，可以通过前一个点的记录，逆序输出路径。

希望这个简单的实现可以帮到您。