用c语言编写用栈解决迷宫问题

好的，我来为你解答这个问题。

首先，我们需要定义一个迷宫的数据结构。我们可以使用一个二维数组来表示迷宫，其中0表示墙，1表示路，2表示起点，3表示终点。同时，我们还需要定义一个栈来保存路径信息。

下面是用C语言实现用栈解决迷宫问题的代码：

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

#define ROW 7   // 迷宫的行数
#define COL 7   // 迷宫的列数

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

typedef struct {
    int row;    // 行号
    int col;    // 列号
}PosType;   // 位置类型

typedef struct {
    PosType seat;    // 元素
    int di;          // 方向
}SElemType; // 元素类型

typedef struct {
    SElemType *base;    // 栈底指针
    SElemType *top;     // 栈顶指针
    int stacksize;      // 栈可用的最大容量
}SqStack;   // 栈类型

// 初始化栈
void InitStack(SqStack *S) {
    S->base = (SElemType*)malloc(sizeof(SElemType));
    if (!S->base) {
        exit(0);
    }
    S->top = S->base;
    S->stacksize = 1;
}

// 进栈
void Push(SqStack *S, SElemType e) {
    if (S->top - S->base >= S->stacksize) {
        S->base = (SElemType*)realloc(S->base, (S->stacksize + 1) * sizeof(SElemType));
        if (!S->base) {
            exit(0);
        }
        S->top = S->base + S->stacksize;
        S->stacksize += 1;
    }
    *(S->top) = e;
    S->top++;
}

// 出栈
void Pop(SqStack *S, SElemType *e) {
    if (S->top == S->base) {
        return;
    }
    S->top--;
    *e = *(S->top);
}

// 判断是否到达终点
int MazePath(PosType start, PosType end) {
    SqStack S;
    SElemType e;
    int i, j, di, find;
    InitStack(&S);
    e.seat = start;
    e.di = -1;
    Push(&S, e);
    maze[start.row][start.col] = -1;
    while (S.top != S.base) {
        Pop(&S, &e);
        i = e.seat.row;
        j = e.seat.col;
        di = e.di + 1;
        while (di < 4) {
            switch (di) {
                case 0:
                    if (maze[i - 1][j] == 1) {
                        e.seat.row = i - 1;
                        e.seat.col = j;
                        e.di = di;
                        Push(&S, e);
                        maze[i - 1][j] = -1;
                        if (e.seat.row == end.row && e.seat.col == end.col) {
                            return 1;
                        }
                        di = -1;
                    }
                    break;
                case 1:
                    if (maze[i][j + 1] == 1) {
                        e.seat.row = i;
                        e.seat.col = j + 1;
                        e.di = di;
                        Push(&S, e);
                        maze[i][j + 1] = -1;
                        if (e.seat.row == end.row && e.seat.col == end.col) {
                            return 1;
                        }
                        di = -1;
                    }
                    break;
                case 2:
                    if (maze[i + 1][j] == 1) {
                        e.seat.row = i + 1;
                        e.seat.col = j;
                        e.di = di;
                        Push(&S, e);
                        maze[i + 1][j] = -1;
                        if (e.seat.row == end.row && e.seat.col == end.col) {
                            return 1;
                        }
                        di = -1;
                    }
                    break;
                case 3:
                    if (maze[i][j - 1] == 1) {
                        e.seat.row = i;
                        e.seat.col = j - 1;
                        e.di = di;
                        Push(&S, e);
                        maze[i][j - 1] = -1;
                        if (e.seat.row == end.row && e.seat.col == end.col) {
                            return 1;
                        }
                        di = -1;
                    }
                    break;
                default:
                    break;
            }
            di++;
        }
    }
    return 0;
}

int main() {
    PosType start = {1, 1};
    PosType end = {5, 5};
    int i, j;
    if (MazePath(start, end)) {
        printf("迷宫路径如下：\n");
        for (i = 0; i < ROW; i++) {
            for (j = 0; j < COL; j++) {
                if (maze[i][j] == -1) {
                    printf("* ");
                }
                else {
                    printf("%d ", maze[i][j]);
                }
            }
            printf("\n");
        }
    }
    else {
        printf("迷宫没有路径！\n");
    }
    return 0;
}

在这个代码中，我们定义了一个迷宫的二维数组`maze`，同时也定义了栈类型`SqStack`和元素类型`SElemType`。我们使用`MazePath`函数来解决迷宫问题，其中`start`表示起点，`end`表示终点。如果存在通路，则返回1，否则返回0。在主函数中，我们定义了起点和终点，并且调用`MazePath`函数来解决迷宫问题。如果存在通路，则输出迷宫路径，否则输出没有路径。