用c语言写一个代码：参考课本迷宫问题的求解，用栈求解迷宫问题的所有路径以及最短路径。

以下是用栈求解迷宫问题的所有路径以及最短路径的C语言代码，参考了课本的算法：

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

#define N 5 // 迷宫大小
#define MAX_STACK_SIZE 100 // 栈的最大大小

// 迷宫地图
int maze[N][N] = {
    {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}
};

// 栈结构体
typedef struct {
    int x, y; // 栈元素表示迷宫的坐标
} StackElem;

// 栈
StackElem stack[MAX_STACK_SIZE];
int top = -1;

// 判断栈是否为空
bool isStackEmpty() {
    return top == -1;
}

// 判断栈是否已满
bool isStackFull() {
    return top == MAX_STACK_SIZE - 1;
}

// 入栈
void push(StackElem elem) {
    if (isStackFull()) {
        printf("Error: stack is full\n");
        exit(EXIT_FAILURE);
    }
    stack[++top] = elem;
}

// 出栈
StackElem pop() {
    if (isStackEmpty()) {
        printf("Error: stack is empty\n");
        exit(EXIT_FAILURE);
    }
    return stack[top--];
}

// 打印栈中的元素
void printStack() {
    int i;
    printf("Path: ");
    for (i = 0; i <= top; i++) {
        printf("(%d,%d) ", stack[i].x, stack[i].y);
    }
    printf("\n");
}

// 判断当前位置是否可走
bool isMovable(int x, int y) {
    if (x < 0 || x >= N || y < 0 || y >= N) { // 越界
        return false;
    }
    if (maze[x][y] == 1) { // 障碍物
        return false;
    }
    return true;
}

// 求解迷宫问题的所有路径
void solveMaze() {
    StackElem cur_pos = {0, 0}; // 当前位置
    StackElem next_pos; // 下一步位置
    push(cur_pos); // 将起点入栈
    while (!isStackEmpty()) {
        cur_pos = pop(); // 取出栈顶元素
        if (cur_pos.x == N - 1 && cur_pos.y == N - 1) { // 到达终点
            printStack(); // 打印路径
            continue; // 继续寻找其他路径
        }
        // 尝试四个方向移动
        if (isMovable(cur_pos.x + 1, cur_pos.y)) { // 向下
            next_pos = (StackElem){cur_pos.x + 1, cur_pos.y};
            push(next_pos);
        }
        if (isMovable(cur_pos.x, cur_pos.y + 1)) { // 向右
            next_pos = (StackElem){cur_pos.x, cur_pos.y + 1};
            push(next_pos);
        }
        if (isMovable(cur_pos.x - 1, cur_pos.y)) { // 向上
            next_pos = (StackElem){cur_pos.x - 1, cur_pos.y};
            push(next_pos);
        }
        if (isMovable(cur_pos.x, cur_pos.y - 1)) { // 向左
            next_pos = (StackElem){cur_pos.x, cur_pos.y - 1};
            push(next_pos);
        }
    }
}

// 求解迷宫问题的最短路径
void solveMazeShortestPath() {
    int dist[N][N]; // 路径长度矩阵
    int i, j, min_dist, min_x, min_y;
    // 初始化距离矩阵
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            dist[i][j] = -1; // -1 表示不可达
        }
    }
    dist[0][0] = 0; // 起点到起点的距离为0
    // 从起点开始向周围节点扩展路径
    while (true) {
        // 找到当前距离最短的未标记节点
        min_dist = -1;
        for (i = 0; i < N; i++) {
            for (j = 0; j < N; j++) {
                if (dist[i][j] != -1) { // 已标记的节点不考虑
                    continue;
                }
                if (isMovable(i, j)) { // 可达的节点才考虑
                    if (min_dist == -1 || dist[i][j] < min_dist) {
                        min_dist = dist[i][j];
                        min_x = i;
                        min_y = j;
                    }
                }
            }
        }
        if (min_dist == -1) { // 所有节点均已标记
            break;
        }
        // 标记周围可达节点的距离
        if (isMovable(min_x + 1, min_y)) { // 向下
            if (dist[min_x + 1][min_y] == -1 || dist[min_x + 1][min_y] > min_dist + 1) {
                dist[min_x + 1][min_y] = min_dist + 1;
            }
        }
        if (isMovable(min_x, min_y + 1)) { // 向右
            if (dist[min_x][min_y + 1] == -1 || dist[min_x][min_y + 1] > min_dist + 1) {
                dist[min_x][min_y + 1] = min_dist + 1;
            }
        }
        if (isMovable(min_x - 1, min_y)) { // 向上
            if (dist[min_x - 1][min_y] == -1 || dist[min_x - 1][min_y] > min_dist + 1) {
                dist[min_x - 1][min_y] = min_dist + 1;
            }
        }
        if (isMovable(min_x, min_y - 1)) { // 向左
            if (dist[min_x][min_y - 1] == -1 || dist[min_x][min_y - 1] > min_dist + 1) {
                dist[min_x][min_y - 1] = min_dist + 1;
            }
        }
    }
    // 打印最短路径长度
    printf("Shortest path length: %d\n", dist[N - 1][N - 1]);
}

int main() {
    solveMaze(); // 求解所有路径
    solveMazeShortestPath(); // 求解最短路径
    return 0;
}

上述代码中，`maze`数组表示迷宫地图，1表示障碍物，0表示可以通过。程序先使用栈求解迷宫问题的所有路径，然后使用 Dijkstra 算法求解迷宫问题的最短路径。其中，`printStack()`函数用于打印栈中元素，即路径节点坐标；`solveMaze()`函数用于求解所有路径；`solveMazeShortestPath()`函数用于求解最短路径。