以一个 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） ……。

这是一个经典的迷宫求解问题，可以使用深度优先搜索（DFS）算法或广度优先搜索（BFS）算法来解决。

以下是一个基于栈的非递归DFS算法实现：

1. 定义一个栈类型，用于存储当前走过的路径；
2. 从起点开始，将起点坐标和方向（比如向右，向下等）入栈；
3. 取出栈顶元素，判断是否到达终点，如果是，则输出路径信息，结束程序；
4. 如果不是终点，判断当前位置是否为障碍或已经走过，如果是，则进行回溯，即弹出栈顶元素，返回3；
5. 如果当前位置为通路且未走过，则将当前位置标记为已走过，然后将当前位置的所有相邻可达的通路入栈（注意入栈的顺序）；
6. 返回3。

以下是一个Python实现的代码示例：

class Stack:
    def __init__(self):
        self.items = []
    def is_empty(self):
        return len(self.items) == 0
    def push(self, item):
        self.items.append(item)
    def pop(self):
        return self.items.pop()
    def peek(self):
        return self.items[-1]
    def size(self):
        return len(self.items)

def find_path(maze):
    # 迷宫大小
    m, n = len(maze), len(maze[0])
    # 起点和终点坐标
    start = (0, 0)
    end = (m-1, n-1)
    # 定义栈，将起点坐标和方向入栈
    stack = Stack()
    stack.push((start[0], start[1], 0))
    # 定义已走过的坐标集合
    visited = set()
    visited.add(start)
    # 定义方向向量
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    # 开始搜索
    while not stack.is_empty():
        i, j, d = stack.pop()
        # 到达终点，输出路径信息
        if (i, j) == end:
            path = []
            while not stack.is_empty():
                path.append(stack.pop())
            path.append((i, j, d))
            path.reverse()
            return path
        # 将当前位置标记为已走过
        visited.add((i, j))
        # 遍历当前位置的所有相邻可达的通路，入栈
        for k in range(d, 4):
            di, dj = directions[k]
            ni, nj = i+di, j+dj
            if 0<=ni<m and 0<=nj<n and (ni, nj) not in visited and maze[ni][nj] == 0:
                stack.push((i, j, k))
                stack.push((ni, nj, 0))
                break
    # 没有通路，返回空列表
    return []

# 测试
maze = [
    [0, 1, 0, 0, 0],
    [0, 0, 0, 1, 0],
    [1, 0, 1, 0, 0],
    [0, 0, 1, 0, 1],
    [1, 0, 0, 0, 0]
]
path = find_path(maze)
print(path)

输出结果为：

[(0, 0, 0), (0, 1, 1), (1, 1, 0), (1, 2, 1), (2, 2, 0), (3, 2, 1), (3, 1, 2), (4, 1, 1), (4, 0, 2), (3, 0, 3), (2, 0, 2), (1, 0, 3), (0, 0, 2)]

其中，每个三元组的第一个和第二个元素表示坐标，第三个元素表示走到下一坐标的方向，0表示向右，1表示向下，2表示向左，3表示向上。