Python数据结构：堆栈——老鼠走迷宫

问题：有一只老鼠被困在迷宫之中了，我们需要实现一个算法，帮助老鼠走出迷宫。
已知迷宫矩阵为：

MAZE=[[1,1,1,1,1,1,1,1,1,1,1,1],\
      [1,0,0,0,1,1,1,1,1,1,1,1],\
      [1,1,1,0,1,1,0,0,0,0,1,1],\
      [1,1,1,0,1,1,0,1,1,0,1,1],\
      [1,1,1,0,0,0,0,1,1,0,1,1],\
      [1,1,1,0,1,1,0,1,1,0,1,1],\
      [1,1,1,0,1,1,0,1,1,0,1,1],\
      [1,1,1,1,1,1,0,1,1,0,1,1],\
      [1,1,0,0,0,0,0,0,1,0,0,1],\
      [1,1,1,1,1,1,1,1,1,1,1,1]]

1表示墙体，无法通过，0表示道路，可以通过。
老鼠的初始位置为[1,1]（第2行第2列）
出口位置为[8,10] (第9行第11列)
利用堆栈数据机构，寻找迷宫的出口

思路：穷举法。把所有的路都走了，总一条是对的。
首先老鼠不走回头路，它随便沿着一个方向一直走，遇到墙壁后换一个方向，直到没有路可以走，那么这条路就是死路。
然后，老鼠开始回退，一直回退到下一个路口，在沿着这条路一直走，以此类推，若存在到达出口的路，那么老鼠一定能走到出口。（因为最差的情况下，老鼠会把所有能走的路走一遍。）
用堆栈记录老鼠走过的路径，堆栈顶端为老鼠当前位置，若下一步有路可走，则压入堆栈，若下一步无路可走，则弹出顶端，一直弹出到有路可走为止。

先简单介绍下堆栈：
堆栈属于抽象数据结构，具有后入先出（First In Last Out,FILO）的特点。

在python中一般会使用数组或者链表来实现堆栈。

用数组来实现堆栈比较简单，但是堆栈大小需要预先给定。太小则不行，太大则浪费内存。
用链表实现堆栈比较复杂，但是不用事先规定大小，更为灵活。

基于事先不知道老鼠需要走多少步，堆栈的大小无法确定，所以采用链表来实现堆栈。

用类来实现链表：

class Node:
    def __init__(self):
        self.x=0
        self.y=0
        self.next=None

用全局变量top来记录堆栈顶端的数据。

压入数据时，新数据的指针指向top（旧顶端），top指向新数据，从而新数据出现在堆栈的顶端（LIFPO）

def push(x,y):
    global top
    new_node=Node()
    new_node.x=x
    new_node.y=y
    new_node.next=top
    top=new_node

弹出数据时，top直接指向top.next

def pop():
    global top
    top=top.next

好的，有了如何压入数据和弹出数据，接下来就该确定老鼠下一步该怎么走。
在这之前要先判断老鼠是否已经到达了出口：
也就是检查当前节点的位置和出口是否相同：
检查节点：

def check_point(x,y,ex,ey):
    if x==ex and y==ey:
        return 1
    else:
        return 0

若相同，我们就停止算法，若不同就
寻找下一步路：
老鼠会沿着一个方向一直走，直到走穿，然后寻找下一个可行的路，并把走过的路记为2（记录走过的路）。
当一条路走到尽头而又不是出口的时候，老鼠会退回到上一个节点。

def next_step(MAZE,ex,ey):
    a=top.x
    b=top.y
    ex=ex
    ey=ey
    if MAZE[a-1][b]==0:
        push(a-1,b)
        MAZE[a-1][b]=2
    elif MAZE[a][b-1]==0:
        push(a,b-1)
        MAZE[a][b-1]=2
    elif MAZE[a+1][b]==0:
        push(a+1,b)
        MAZE[a+1][b]=2
    elif MAZE[a][b+1]==0:
        push(a,b+1)
        MAZE[a][b+1]=2
    else:
        pop()

若老鼠走到了出口，那么停止算法，否则，老鼠会一直寻路。

def find_road(MAZE,x,y,ex,ey):
    global top
    a=ex
    b=ey
    head=Node()
    head.x=x
    head.y=y
    head.next=None
    top=head
    while check_point(top.x,top.y,a,b)==0:
        next_step(MAZE,a,b)
        
    print('老鼠走过的路为：')
    for i in range(10):
        for j in range(12):
            print(MAZE[i][j],end='')
        print()

老鼠走的正确的路径，也就是堆栈中的数据的坐标记为3：

while top!=None:
    MAZE[top.x][top.y]=3
    top=top.next
for i in range(10):
        for j in range(12):
            print(MAZE[i][j],end='')
        print()

完整代码如下：

class Node:
    def __init__(self):
        self.x=0
        self.y=0
        self.next=None

def push(x,y):
    global top
    new_node=Node()
    new_node.x=x
    new_node.y=y
    new_node.next=top
    top=new_node
    
def pop():
    global top
    top=top.next
    
def check_point(x,y,ex,ey):
    if x==ex and y==ey:
        return 1
    else:
        return 0
    
def next_step(MAZE,ex,ey):
    a=top.x
    b=top.y
    ex=ex
    ey=ey
    if MAZE[a-1][b]==0:
        push(a-1,b)
        MAZE[a-1][b]=2
    elif MAZE[a][b-1]==0:
        push(a,b-1)
        MAZE[a][b-1]=2
    elif MAZE[a+1][b]==0:
        push(a+1,b)
        MAZE[a+1][b]=2
    elif MAZE[a][b+1]==0:
        push(a,b+1)
        MAZE[a][b+1]=2
    else:
        pop()
        
def find_road(MAZE,x,y,ex,ey):
    global top
    a=ex
    b=ey
    head=Node()
    head.x=x
    head.y=y
    head.next=None
    top=head
    while check_point(top.x,top.y,a,b)==0:
        next_step(MAZE,a,b)
        
    print('老鼠走过的路为：')
    for i in range(10):
        for j in range(12):
            print(MAZE[i][j],end='')
        print()
            
    
MAZE=[[1,1,1,1,1,1,1,1,1,1,1,1],\
      [1,0,0,0,1,1,1,1,1,1,1,1],\
      [1,1,1,0,1,1,0,0,0,0,1,1],\
      [1,1,1,0,1,1,0,1,1,0,1,1],\
      [1,1,1,0,0,0,0,1,1,0,1,1],\
      [1,1,1,0,1,1,0,1,1,0,1,1],\
      [1,1,1,0,1,1,0,1,1,0,1,1],\
      [1,1,1,1,1,1,0,1,1,0,1,1],\
      [1,1,0,0,0,0,0,0,1,0,0,1],\
      [1,1,1,1,1,1,1,1,1,1,1,1]]
x=1
y=1
ex=8
ey=10
print('='*20)
print('迷宫为:')
for i in range(10):
        for j in range(12):
            print(MAZE[i][j],end='')
        print()
print('='*20)
find_road(MAZE,x,y,ex,ey)
print('='*20)
while top!=None:
    MAZE[top.x][top.y]=3
    top=top.next
for i in range(10):
        for j in range(12):
            print(MAZE[i][j],end='')
        print()
while top!=None:
    MAZE[top.x][top.y]=3
    top=top.next
for i in range(10):
        for j in range(12):
            print(MAZE[i][j],end='')
        print()

输出结果如下：

====================
迷宫为:
111111111111
100011111111
111011000011
111011011011
111000011011
111011011011
111011011011
111111011011
110000001001
111111111111
====================
老鼠走过的路为：
111111111111
122211111111
111211222211
111211211211
111222211211
111211011211
111211011211
111111011211
110000001221
111111111111
====================

111111111111
133311111111
111311333311
111311311311
111333311311
111211011311
111211011311
111111011311
110000001331
111111111111