【栈和队列的应用~python】

---

栈和队列的应用

# -*- coding = utf-8 -*-
# @Time : 2022/5/14 13:20
# @Author : lxw_pro
# @File : py-15.py
# @Software : PyCharm

# 栈和队列的应用————迷宫问题：      ————回溯法             深度优先搜索
moze = [
    [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):
    stack = []
    stack.append((x1, y1))
    while len(stack) > 0:
        curNode = stack[-1]
        # x, y  -四个方向x, y+1
        if curNode[0] == x2 and curNode[1] == y2:
            for p in stack:
                print(p)
            return True
        for dir in dirs:
            nextNode = dir(curNode[0], curNode[1])
            # 如果下一节点能走
            if moze[nextNode[0]][nextNode[1]] == 0:
                stack.append(nextNode)
                moze[nextNode[0]][nextNode[1]] = 2
                break
        else:
            moze[nextNode[0]][nextNode[1]] = 2
            stack.pop()
    else:
        print("没路啦")
        return False


maze_path(1, 1, 8, 8)


# BFS算法~个人小总结：
# BFS找到的路径一定是最短的，但代价是空间复杂度比DFS大很多。
# 无论传统BFS还是双向BFS，无论做不做优化，从Big O的衡量标准来看，空间复杂度都是一样的。

---

队列的迷宫实现

# -*- coding = utf-8 -*-
# @Time : 2022/5/14 13:52
# @Author : lxw_pro
# @File : py-16.py
# @Software : PyCharm

# 队列的迷宫实现：
from collections import deque
moze = [
    [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 moze_path_queue(x1, y1, x2, y2):
    queue = deque()
    queue.append((x1, y1, -1))
    path = []
    while len(queue) > 0:
        curNode = queue.pop()
        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 moze[nextNode[0]][nextNode[1]] == 0:
                queue.append((nextNode[0], nextNode[1], len(path)-1))     # 后续节点进队，记录哪个节点带他来的
                moze[nextNode[0]][nextNode[1]] = 2                      # 标记为已经走过
    else:
        print("没有路")
        return False


moze_path_queue(1, 1, 8, 8)

上一章链接：栈的简单实现及应用~python

---

江湖一言：

在任何一组东西中，最重要的只占其中一小部分约20%，其余80%尽管是多数，却是次要的。

---

持续更新中…