以一个 m×n 的长方阵表示迷宫0 和1分别表示迷宫中的通路和障碍。设计一个程序对任意设定的迷宫求出一条从入口到出口的通路或得出没有通路的结论。要求实现以下功能：1以链表作存储结构的栈类型编写一个求解迷宫的非递归程序。求得的通路以 ij 的形式按通路顺序输出其中ij 为迷宫中的一个坐标。2求得迷宫中所有可能的通路并输出最短路径。

以下是基于深度优先搜索（DFS）算法的非递归解决迷宫问题的程序：

class StackNode:
    def __init__(self, x, y, direction):
        self.x = x
        self.y = y
        self.direction = direction

def MazeSolver(maze):
    stack = []
    stack.append(StackNode(0, 0, -1))  # 入口点
    maze[0][0] = -1  # 标记入口点已经访问过
    
    while len(stack) > 0:
        current_node = stack[-1]  # 栈顶元素
        x = current_node.x
        y = current_node.y
        direction = current_node.direction + 1
        
        if x == len(maze)-1 and y == len(maze[0])-1:
            # 到达出口点
            path = []
            for node in stack:
                path.append((node.x, node.y))
            return path
        
        # 检查下一个可能的移动方向
        found = False
        while direction < 4:
            next_x = x
            next_y = y
            if direction == 0:  # 向上移动
                next_x -= 1
            elif direction == 1:  # 向右移动
                next_y += 1
            elif direction == 2:  # 向下移动
                next_x += 1
            elif direction == 3:  # 向左移动
                next_y -= 1
            
            if next_x >= 0 and next_x < len(maze) and next_y >= 0 and next_y < len(maze[0]) and maze[next_x][next_y] == 0:
                # 下一个位置是合法的通路
                stack.append(StackNode(next_x, next_y, -1))
                maze[next_x][next_y] = -1  # 标记已经访问过
                found = True
                break
            
            direction += 1
        
        if not found:
            # 没有找到下一个可行的移动方向，回退
            stack.pop()
    
    return None

maze = [
    [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]
]

path = MazeSolver(maze)
if path is not None:
    print("迷宫路径：", path)
else:
    print("没有通路")

对于每个可能的通路，可以使用广度优先搜索（BFS）算法来找到最短路径。以下是基于BFS算法的程序：

from collections import deque

class Point:
    def __init__(self, x, y, distance):
        self.x = x
        self.y = y
        self.distance = distance

def findShortestPath(maze):
    queue = deque()
    queue.append(Point(0, 0, 0))  # 入口点
    maze[0][0] = -1  # 标记入口点已经访问过
    
    while len(queue) > 0:
        current_point = queue.popleft()  # 队首元素
        x = current_point.x
        y = current_point.y
        distance = current_point.distance
        
        if x == len(maze)-1 and y == len(maze[0])-1:
            # 到达出口点
            return distance
        
        # 检查下一个可能的移动方向
        directions = [(-1, 0), (0, 1), (1, 0), (0, -1)]  # 上、右、下、左
        for direction in directions:
            next_x = x + direction[0]
            next_y = y + direction[1]
            
            if next_x >= 0 and next_x < len(maze) and next_y >= 0 and next_y < len(maze[0]) and maze[next_x][next_y] == 0:
                # 下一个位置是合法的通路
                queue.append(Point(next_x, next_y, distance+1))
                maze[next_x][next_y] = -1  # 标记已经访问过
    
    return -1

maze = [
    [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]
]

shortest_path = findShortestPath(maze)
if shortest_path != -1:
    print("最短路径长度：", shortest_path)
else:
    print("没有通路")

请注意，以上程序假设迷宫的入口点为 (0, 0)，出口点为 (m-1, n-1)，其中 m 和 n 分别是迷宫的行数和列数