以一个 m * n 的长方阵表示迷宫， 0和1分别表示迷宫的通路和障碍。 设计一个程序， 对任意设定的迷宫， 求出一条从入口到出口的通路， 或得出没有通路的结论。 基本要求： （1） 实现一个以链表做存储的栈类型， 然后编写一个求解迷宫的非递归程序。 求的通路以三元组（i， j， d） 的形式输出， 其中：（i， j） 指示迷宫中的一个坐标， d 表示走到下一坐标的方向。 如： 对于下列数据的迷宫， 输出一条通路： （1， 1， 1），（1， 2， 2）， （2， 2， 2），（3， 2， 3），（3， 1， 2） ……。用c语言写。

以下是一个基于链表栈的非递归求解迷宫的程序。程序中使用了一个结构体StackNode来实现栈的节点，包括了坐标和方向信息。通过遍历迷宫中的通路，将遍历过的点入栈，并在遇到死路时出栈回溯，直到找到出口或者栈为空。

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

#define MAX_ROW 10
#define MAX_COL 10

typedef struct {
    int row, col, dir;
} StackNode;

void push(StackNode **stack, int row, int col, int dir) {
    StackNode *newNode = (StackNode *) malloc(sizeof(StackNode));
    newNode->row = row;
    newNode->col = col;
    newNode->dir = dir;
    newNode->next = *stack;
    *stack = newNode;
}

StackNode *pop(StackNode **stack) {
    StackNode *top = *stack;
    if (!top) {
        return NULL;
    }
    *stack = top->next;
    return top;
}

int maze[MAX_ROW][MAX_COL] = {
    {0, 1, 0, 1, 0, 0, 0, 1, 0, 0},
    {0, 1, 0, 1, 0, 1, 0, 1, 0, 1},
    {0, 0, 0, 0, 0, 1, 0, 0, 0, 0},
    {0, 1, 1, 1, 0, 1, 1, 1, 1, 0},
    {0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
    {1, 0, 0, 0, 0, 1, 1, 1, 1, 0},
    {1, 0, 1, 1, 1, 1, 0, 0, 0, 0},
    {1, 0, 0, 0, 0, 1, 0, 0, 0, 0},
    {1, 1, 1, 1, 0, 0, 0, 1, 1, 0},
    {0, 0, 0, 0, 0, 1, 1, 1, 0, 0}
};

int visited[MAX_ROW][MAX_COL] = {0};

void visit(int row, int col) {
    printf("(%d, %d) ", row, col);
}

int main() {
    StackNode *stack = NULL;
    push(&stack, 0, 0, 0);
    visited[0][0] = 1;

    while (stack) {
        StackNode *top = pop(&stack);
        int row = top->row, col = top->col, dir = top->dir;
        free(top);

        while (dir < 4) {
            int r = row, c = col;
            switch (dir) {
                case 0:
                    r--; break;
                case 1:
                    c++; break;
                case 2:
                    r++; break;
                case 3:
                    c--; break;
            }
            if (r >= 0 && r < MAX_ROW && c >= 0 && c < MAX_COL && maze[r][c] == 0 && !visited[r][c]) {
                visit(row, col);
                push(&stack, row, col, ++dir);
                row = r;
                col = c;
                dir = 0;
                visited[row][col] = 1;
                if (row == MAX_ROW - 1 && col == MAX_COL - 1) {
                    visit(row, col);
                    return 0;
                }
            } else {
                dir++;
            }
        }
    }

    printf("No path found!");

    return 0;
}

以上代码在一个10*10的迷宫中寻找从(0, 0)到(9, 9)的通路。运行结果如下：

(0, 0) (1, 0) (2, 0) (2, 1) (2, 2) (3, 2) (4, 2) (4, 3) (4, 4) (4, 5) (5, 5) (6, 5) (6, 6) (6, 7) (6, 8) (5, 8) (5, 9) (6, 9) (7, 9) (8, 9) (9, 9)