广度优先搜索算法（BFS)

1.广度优先搜索是个常用的图搜索方法。一般用队列的形式实现算法。

算法步骤如下：

1.创建队列

2.弹出第一个节点，按照条件进行搜索。

3.将满足条件的点，加入队列。

4.重复步骤2和3，直到队列为空。

python 版本伪代码：

# 创建队列

1. deque = []

# 将开始节点加入队列

2.deque.append(start_node)

3.while deque:

            # 弹出第一个节点

            current_node = deque.pop(0)

            # 按照条件搜索

            next_node = ....

            # 将满足条件的节点加入队列

            deque.append(next_node)

广度优先算法一般可以解决最短路径问题。

比如走出迷宫最少需要几步。

# 迷宫，1表示障碍物，0表示可通行
map_array = [[0, 0, 0, 0, 0, 0, 0, 0],
             [0, 1, 1, 0, 0, 1, 0, 0],
             [0, 1, 0, 0, 0, 0, 0, 0],
             ['B', 0, 1, 0, 1, 0, 0, 'E']]


def find_index(map_array, tag_name):
    index_x, index_y = 0, 0
    for i in range(len(map_array)):
        for j in range(len(map_array[0])):
            if map_array[i][j] == tag_name:
                index_x, index_y = i, j
    return index_x, index_y
#找到入口和出口
start_x, start_y = find_index(map_array, 'B')
end_x, end_y = find_index(map_array, 'E')

#将出口置为0，可通过
map_array[end_x][end_y] = 0
# 计算步数
step_map = [[0 for _ in range(len(map_array[0]))] for i in range(len(map_array))]
step_map[start_x][start_y] = 1

# BFS 部分
next_step = [[0, 1], [1, 0], [0, -1], [-1, 0]]  # 迷宫的四种走法
# 1.创建队列
deque = []
2.追加开始节点
deque.append([start_x, start_y])
3.判断队列是否为空
while len(deque)>0:
    # 弹出节点，并将该位置，置为2，表示已访问
    x, y = deque.pop(0)
    map_array[x][y] = 2
    # 判断是否为出口
    if x == end_x and y == end_y:
        print('最短步数',step_map[x][y])
        print('找到出口')
        break
    # 按照条件进行搜索，可以从4个方向，上下左右进行查找
    for n in next_step:
        i, j = x + n[0], y + n[1]
        if i < 0 or j < 0 or i > len(map_array)-1 or j > len(map_array[0])-1:
            continue
        # 如果该节点未被访问，则加入队列。
        if map_array[i][j] == 0:
            if [i, j] not in deque:
                deque.append([i, j])
            # 计算步数
            step_map[i][j] = step_map[x][y]+1

最后输出：

最短步数 14
找到出口
[4, 5, 6, 7, 8, 9, 10, 11]
[3, 0, 0, 8, 9, 0, 11, 12]
[2, 0, 10, 9, 10, 11, 12, 13]
[1, 2, 0, 10, 0, 12, 13, 14]

可以看到step_map中最短路径为14.