用c语言编写用栈解决迷宫问题用,迷宫的大小(8*8),用二维数组构造迷宫,并且规定方向0—3代表 上下左右。Path方法存放路径。随机使用0和1填充迷宫,0为不可通过点,1 为可通过点。记录好起点和终点。.栈:用栈格式

好的，以下是用C语言编写的栈解决迷宫问题的代码：

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

#define MAX_SIZE 100

// 定义坐标结构体
typedef struct {
    int x;
    int y;
} Position;

// 栈结构体
typedef struct {
    Position data[MAX_SIZE];
    int top;
} Stack;

// 初始化栈
void init(Stack *s) {
    s->top = -1;
}

// 入栈
void push(Stack *s, Position p) {
    if (s->top == MAX_SIZE - 1) {
        printf("栈已满，无法入栈\n");
        return;
    }
    s->data[++s->top] = p;
}

// 出栈
Position pop(Stack *s) {
    if (s->top == -1) {
        printf("栈已空，无法出栈\n");
        Position p = {-1, -1};
        return p;
    }
    return s->data[s->top--];
}

// 判断栈是否为空
int is_empty(Stack *s) {
    return s->top == -1 ? 1 : 0;
}

// 解决迷宫问题
void Path(int maze[][8], int row, int col, Position start, Position end) {
    Stack s;
    Position cur = start; // 当前位置
    init(&s); // 初始化栈
    push(&s, cur); // 将起点入栈

    while (!is_empty(&s)) {
        cur = pop(&s); // 出栈
        if (cur.x == end.x && cur.y == end.y) { // 到达终点
            printf("(%d, %d) ", cur.x, cur.y);
            while (!is_empty(&s)) { // 输出路径
                cur = pop(&s);
                printf("-> (%d, %d) ", cur.x, cur.y);
            }
            printf("\n");
            return;
        }
        if (maze[cur.x][cur.y] == 0) { // 当前位置为障碍物，跳过
            continue;
        }
        maze[cur.x][cur.y] = 0; // 标记当前位置已走过
        // 向上走
        if (cur.x > 0 && maze[cur.x-1][cur.y] == 1) {
            Position next = {cur.x-1, cur.y};
            push(&s, next);
        }
        // 向下走
        if (cur.x < row-1 && maze[cur.x+1][cur.y] == 1) {
            Position next = {cur.x+1, cur.y};
            push(&s, next);
        }
        // 向左走
        if (cur.y > 0 && maze[cur.x][cur.y-1] == 1) {
            Position next = {cur.x, cur.y-1};
            push(&s, next);
        }
        // 向右走
        if (cur.y < col-1 && maze[cur.x][cur.y+1] == 1) {
            Position next = {cur.x, cur.y+1};
            push(&s, next);
        }
    }
    printf("无法到达终点\n");
}

int main() {
    int maze[8][8]; // 迷宫数组
    Position start = {0, 0}; // 起点
    Position end = {7, 7}; // 终点

    // 随机生成迷宫
    srand((unsigned)time(NULL));
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            maze[i][j] = rand() % 2;
        }
    }
    maze[start.x][start.y] = 1; // 起点可通过
    maze[end.x][end.y] = 1; // 终点可通过

    // 输出迷宫
    printf("迷宫：\n");
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            printf("%d ", maze[i][j]);
        }
        printf("\n");
    }

    // 解决迷宫问题
    printf("从起点到终点的路径为：\n");
    Path(maze, 8, 8, start, end);

    return 0;
}

以上代码中，我们首先定义了一个坐标结构体 `Position` 和一个栈结构体 `Stack`，并分别实现了入栈、出栈、初始化栈和判断栈是否为空的函数。

在 `Path` 函数中，我们使用栈来记录路径。从起点开始，将起点入栈。然后循环进行以下操作：

1. 出栈，获取当前位置。
2. 如果当前位置为终点，则输出路径并返回。
3. 如果当前位置为障碍物，则跳过。
4. 标记当前位置已走过。
5. 向上、下、左、右四个方向探索，如果下一个位置可以通过，则将其入栈。

最后，我们在 `main` 函数中随机生成迷宫，并将起点和终点标记为可通过。然后调用 `Path` 函数求解迷宫问题，并输出路径。