用c语言写广度优先遍历查找迷宫最短路径 功能描述：广度优先遍历查找迷宫最短路径，并打印出路径对应的坐标信息，从矩阵中的终点位置，沿8个方向，查找值为0的点， 利用q.x[]存放值为0的数据对应的横坐标的值，q.y[]存放值为0的数据对应的纵坐标的值， g.flag[][]存放结点是否访问过，访问过设置为1，未被访问设置为0 q.pre[]存放当前结点所对应的前驱结点在q.x[]，q.y[]中的数组下标信息。 打印出迷宫的坐标信息 printf("(%d,%d)\n", 横坐标, 纵坐标);

好的，以下是参考代码：

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

#define MAXN 100
#define MAXM 100
#define INF 0x3f3f3f3f

int n, m;  // 迷宫大小
int sx, sy;  // 起点坐标
int tx, ty;  // 终点坐标
int maze[MAXN][MAXM];  // 迷宫地图
int flag[MAXN][MAXM];  // 是否已访问
int pre[MAXN][MAXM][2];  // 前驱结点坐标

struct Queue {
    int x[MAXN * MAXM], y[MAXN * MAXM];
    int head, tail;
    void init() { head = tail = 0; }
    void push(int xx, int yy) { x[tail] = xx; y[tail] = yy; tail++; }
    void pop() { head++; }
    bool empty() { return head == tail; }
    int front_x() { return x[head]; }
    int front_y() { return y[head]; }
} q;

int dx[8] = {-1, -1, 0, 1, 1, 1, 0, -1};  // 方向数组
int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};

void bfs()
{
    memset(flag, 0, sizeof(flag));  // 初始化
    flag[tx][ty] = 1;
    q.init();
    q.push(tx, ty);
    while (!q.empty()) {
        int x = q.front_x(), y = q.front_y();
        q.pop();
        for (int i = 0; i < 8; i++) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;  // 越界
            if (maze[nx][ny] == 1) continue;  // 墙
            if (flag[nx][ny]) continue;  // 已访问
            flag[nx][ny] = 1;
            pre[nx][ny][0] = x; pre[nx][ny][1] = y;  // 记录前驱结点
            q.push(nx, ny);
        }
    }
}

void print_path()
{
    int x = sx, y = sy;
    while (x != tx || y != ty) {  // 回溯路径
        printf("(%d,%d)\n", x, y);
        int tx = pre[x][y][0], ty = pre[x][y][1];
        x = tx; y = ty;
    }
    printf("(%d,%d)\n", tx, ty);  // 打印终点
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &maze[i][j]);
            if (maze[i][j] == 2) {
                sx = i; sy = j;
            } else if (maze[i][j] == 3) {
                tx = i; ty = j;
            }
        }
    }
    bfs();  // 广搜
    print_path();  // 打印路径
    return 0;
}

在上面的代码中，我们使用了一个结构体 `Queue` 来实现队列，其中 `x` 和 `y` 数组分别存放队列中每个元素的横坐标和纵坐标。在 `bfs` 函数中，我们先将终点入队，然后开始进行广搜。对于每个出队结点，我们枚举其周围的 8 个方向，并判断是否可以走到该点，如果可以，则将其入队。同时，我们还要记录每个结点的前驱结点坐标，以便在找到终点后回溯路径。

最后，我们调用 `print_path` 函数打印路径，该函数从终点开始沿着前驱结点回溯找到起点，并打印每个路径点的坐标信息。