数据结构与算法【Python实现】（三）栈和队列应用——迷宫问题

一个二维列表表示迷宫(0表示通道，1表示围墙)，给出算法，求一条走出迷宫的路径

1、使用栈——深度优先搜索

回溯法 

一条路走到黑，不行就回退

思路：从一个节点开始，任意寻找下一个能走的点，当找不到能走的点时，退回上一个点寻找是否有其他方向的点

使用栈存储当前路径，没有路时出栈

maze = [
    [1,1,1,1,1,1,1,1,1,1],
    [1,0,0,1,0,0,0,1,0,1],
    [1,0,0,1,0,0,0,1,0,1],
    [1,0,0,0,0,1,1,0,0,1],
    [1,0,1,1,1,0,0,0,0,1],
    [1,0,0,0,1,0,0,0,0,1],
    [1,0,1,0,0,0,1,0,0,1],
    [1,0,1,1,1,0,1,1,0,1],
    [1,1,0,0,0,0,0,0,0,1],
    [1,1,1,1,1,1,1,1,1,1]
]

dirs = [   #方向
    lambda x,y:(x+1,y),
    lambda x,y:(x-1,y),
    lambda x,y:(x,y+1),
    lambda x,y:(x,y-1)
]


def maze_path(x1,y1,x2,y2): # x1 y1起点位置  x2 y2终点位置
    stack = []
    stack.append((x1,y1))  #栈中保存元组
    while(len(stack)>0):
        curNode = stack[-1]  #当前节点 栈顶
        if curNode[0] == x2 and curNode[1] == y2:  #走到终点
            for p in stack:
                print(p)
            return True
        #(x,y)四个方向  上x-1,y  下x+1,y  左x,y-1  右x,y+1
        for dir in dirs:
            nextNode = dir(curNode[0],curNode[1])  #下一个节点
            if maze[nextNode[0]][nextNode[1]] == 0:  #下一个节点能走
                stack.append(nextNode)  #把下一个节点加入栈里
                maze[nextNode[0]][nextNode[1]] = 2  #标记为已走过
                break
        else:  #如果四个方向都不能走
            maze[curNode[0]][curNode[1]] == 2
            stack.pop()  #栈顶出栈
    else:  #栈跳出了 没有路
        print("没有路")
        return False


maze_path(1,1,8,8)

缺点：找到的路不是最短的路径

2、使用队列——广度优先搜索

思路：从一个节点开始，寻找所有接下来能继续走的点，继续不断寻找，直到找到出口

使用队列存储当前正在考虑的点

找到的是最短的路

from collections import deque

maze = [
    [1,1,1,1,1,1,1,1,1,1],
    [1,0,0,1,0,0,0,1,0,1],
    [1,0,0,1,0,0,0,1,0,1],
    [1,0,0,0,0,1,1,0,0,1],
    [1,0,1,1,1,0,0,0,0,1],
    [1,0,0,0,1,0,0,0,0,1],
    [1,0,1,0,0,0,1,0,0,1],
    [1,0,1,1,1,0,1,1,0,1],
    [1,1,0,0,0,0,0,0,0,1],
    [1,1,1,1,1,1,1,1,1,1]
]

dirs = [   #方向
    lambda x,y:(x+1,y),
    lambda x,y:(x-1,y),
    lambda x,y:(x,y+1),
    lambda x,y:(x,y-1)
]

def print_r(path):
    curNode = path[-1]  #终点
    realpath = []
    while curNode[2] != -1:
        realpath.append(curNode[0:2])
        curNode = path[curNode[2]]
    realpath.append(curNode[0:2])   #起点加进去
    realpath.reverse()
    for node in realpath:
        print(node)


def maze_path(x1,y1,x2,y2):
    queue = deque()
    queue.append((x1, y1, -1))  #最后一个是 从第几个位置过来的（源头）
    path = []
    while len(queue) > 0:  #只要队不空
        curNode = queue.popleft()
        path.append(curNode)  #存出队的位置
        if curNode[0] == x2 and curNode[1] == y2:  #找到终点
            print_r(path)
            return True

        for dir in dirs:
            nextNode = dir(curNode[0],curNode[1])  #下一个节点
            if maze[nextNode[0]][nextNode[1]] == 0:
                queue.append((nextNode[0], nextNode[1], len(path)-1))  #下一个节点和源头 入栈
                maze[nextNode[0]][nextNode[1]] = 2  #标记为已走过
    else:
        print("没有路")
        return False


maze_path(1,1,8,8)