python 队列 广度优先搜索

刚开始队列里面只有1，1出队，2进队，2出队，3进队，3出队，4和5进队，4出队，6进队现在队列里面是5和6，5出队，7进队，队列里面现在是6和7，6出队，8和9进队，队列里面还有7、8、9，7出队10进队，队列里面还有8、9、10

出队 1 2 3 4 5 6 7

那个点让他来的 没有那我写个-1 0 1 2 2 3 4

出队序列 0 1 2 3 4 5 6 7 8 9 10

1出队
2进队，2出队，2是从哪来的从1过来，1呢是0
3进队，3出队，3是从哪来的从2来的 ，写1
4和5进队，4出队，4从哪来的从3的位置来，写2，
5出队，5从哪来的，从3来的，写2
6出队，6从哪来的，从4来的，写3
7出队 ，7从哪来的，从5来的，5在4号位置，7写4

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)
]

#path是出的节点，有好多路径
def print_r(path):
    #最后一个元素就是终点
    curNode = path[-1]

    #这是真正路径  这是一条到终点
    realpath = []

    #终点到起到走的  等于-1找的是最开始的
    while curNode[2] != -1:
        # 真正的路径 #意思就是 curNode[0],curNode[1]
        realpath.append(curNode[0:2])
        #下一个节点
        curNode = path[curNode[2]]

    #等于-1的点，那个点是起点
    realpath.append(curNode[0:2])  # 起点
    //反转
    realpath.reverse()
    #print(realpath)
    #列表循环打印
    for node in realpath:
        print(node)

//x1和y1 是起点的位置   x2和y2是终点的位置
def maze_path_queue(x1, y1, x2, y2):
    #创建队列
    queue = deque()

    #记录谁让它来的 ,列表  下标哪个元素让他来的
    path = []
    # 0是x 1是y ,谁让你来的记录一下  起点是-1
    queue.append((x1, y1, -1))

    #这个是从终点到起点 ,所以取最后一个值  只要队不空 
    while len(queue) > 0:
        #当前节点是队首,队首要出来,出队
        curNode = queue.popleft()
        #出队的节点放进去      0就是最后一个元素的下标      curNode存在path这个列表位置就是下标,curNode肯定存在最后一个位置,所有0就是存在最后一个位置
        path.append(curNode)
        if curNode[0] == x2 and curNode[1] == y2:
            # 终点
            print_r(path)
            return True
        #把curNode 后面的所有节点都放进队列，是个方向四个方向
        for dir in dirs:
            nextNode = dir(curNode[0], curNode[1])
            #能走等于0
            if maze[nextNode[0]][nextNode[1]] == 0:
                #能走进队,x  ,y ,谁让它来的    len(path) - 1最后一个元素的下标         nextNode是由curNode带进来的
                queue.append((nextNode[0], nextNode[1], len(path) - 1))  # 后续节点进队，记录哪个节点带他来的
                maze[nextNode[0]][nextNode[1]] = 2  # 标记为已经走过
    else:
        print("没有路")
        return False
# 谁让它来的是path当前最后一个, nextNode是由curNode带进来的,curNode存在path这个列表位置就是下标,curNode肯定存在path最后一个位置,所有就写path最后元素的位置

maze_path_queue(1, 1, 8, 8)