深度优先搜索(DFS)

与bfs类似，也是一种图搜索算法，和bfs略有区别，主要是搜索的方式不同。主要是利用栈的方式。算法流程如下：

1.创建栈

2.将开始节点入栈。

3.按照条件，搜索下一个节点，将满足条件的节点加入栈。

重复3.直到满足终止条件。

与bfs不同，dfs经常使用递归的方式去搜索。

以迷宫搜索路径为例。

采用非递归的方式，即在搜索时，用栈来保存结果。

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, 1, 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]
]

# 非递归DFS
def solve_maze_with_stack(x1, y1, x2, y2):
    next_steps = [[-1,0],[0,-1],[1,0],[0,1]]
    #创建栈
    stack = []
    # 开始节点加入栈
    stack.append((x1, y1))
    maze[x1][y1] = 2  # 表示已经走过的路
    while len(stack) > 0:
        # 判断当前节点是否为终点
        cur_node = stack[-1]
        if cur_node == (x2, y2):
            print(stack)
            return True
        # 按照条件进行下一步搜索
        for dir_x,dir_y in next_steps:
            next_x, next_y = cur_node[0]+dir_x,cur_node[1]+dir_y
            # 满足搜索条件，加入栈，break，对加入栈的节点进行下一步搜索
            if maze[next_x][next_y] == 0:
                stack.append((next_x, next_y))
                maze[next_x][next_y] = 2
                break
        # 回溯，如果当前节点，没有下一步可加入的栈，将该节点出栈
        else:
            stack.pop()
    print('无路可走')
    return False
solve_maze_with_stack(x1,y1,x2,y2)

采用递归的方式，即在节点搜索时，递归调用dfs函数

# DFS 递归
def solve_maze_dfs(x1, y1, x2, y2):
    # dfs 递归函数
    def dfs(i,j,x2,y2,stack):
        next_steps = [[1, 0], [0, 1], [-1, 0], [0, -1]]
        # 判断是否为终点
        if i == x2 and j == y2:
            print(stack)
            print('已找到出口')
            return True
        # 进行下一步查找
        for nx,ny in next_steps:
            i_ = i+nx
            j_ = j+ny
            if 0 <= i_ < len(maze) and 0 <= j_ < len(maze[0]) and maze[i_][j_] == 0:
                maze[i_][j_] = 2
                stack.append([i_,j_])
                # 找到下一个 进行dfs 递归
                dfs(i_,j_,x2,y2,stack)
        # 如果下一步没有节点，则出栈，回溯该节点。
        else:
            stack.pop()
            maze[i][j] = 0

    # 创建栈
    stack = []
    maze[x1][y1] = 2
    stack.append([x1,y1])
    dfs(x1, y1, x2, y2,stack)