python 经典算法之--广度优先搜索算法(Breadth-First Search Algorithm)
广度优先搜索算法(Breadth-First Search Algorithm)是一种图形搜索算法，用于在图形或树中遍历或搜索数据结构。
其基本思路是从根节点开始扫描整个图，按照层次顺序依次访问每个节点，每一层访问完后才会进入下一层。
例如，在寻找从起点到终点的最短路径时，广度优先搜索算法是一种有效的方法。具体来说，该算法首先将起点加入队列中，然后从队列中取出第一个节点，扫描该节点的所有邻居节点并将其加入队列中，然后重复这个过程，直到找到终点或者队列为空为止。
以下是两个完整的例子：
示例1：在一个图中查找最短路径
# 定义一个有向图，使用邻接表表示法
graph = {1: [2, 3], 2: [4, 5], 3: [4, 6], 4: [6], 5: [4], 6: []}
# 定义起点和终点
start = 1
end = 6
# 定义一个队列，用于存储遍历的节点
queue = []
# 定义一个标记数组，标记节点是否已经被遍历过
visited = [0] * (len(graph) + 1)
# 将起点加入队列中
queue.append(start)
visited[start] = 1
# 定义一个字典，用于记录每个节点的前一个节点，最终用于查找最短路径
prev = {start: None}
# 广度优先搜索
while queue:
node = queue.pop(0)
for neighbor in graph[node]:
if not visited[neighbor]:
queue.append(neighbor)
visited[neighbor] = 1
prev[neighbor] = node
if neighbor == end:
path = []
while node:
path.append(node)
node = prev[node]
print('最短路径为：', path[::-1])
break
示例2：在一个迷宫中查找最短路径
# 定义一个迷宫地图
maze = [
[0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[1, 1, 1, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 1, 0]
]
# 定义起点和终点
start = (0, 0)
end = (6, 6)
# 定义一个队列，用于存储遍历的节点
queue = []
# 定义一个标记数组，标记节点是否已经被遍历过
visited = [[0] * 7 for _ in range(7)]
# 定义一个字典，用于记录每个节点的前一个节点，最终用于查找最短路径
prev = {start: None}
# 广度优先搜索
queue.append(start)
visited[start[0]][start[1]] = 1
row_nums = [-1, 0, 1, 0]
col_nums = [0, 1, 0, -1]
while queue:
node = queue.pop(0)
for i in range(4):
row = node[0] + row_nums[i]
col = node[1] + col_nums[i]
if 0 <= row < len(maze) and 0 <= col < len(maze[0]) and not visited[row][col] and maze[row][col] == 0:
queue.append((row, col))
visited[row][col] = 1
prev[(row, col)] = node
if (row, col) == end:
path = [(row, col)]
while node:
path.append(node)
node = prev[node]
print('最短路径为：', path[::-1])
break
以上两个例子都是使用广度优先搜索算法找到了起点到终点的最短路径。其中，第一个例子是在一个有向图中查找最短路劲，第二个例子是在一个二维数组迷宫中查找最短路径。
广度优先搜索算法(Breadth-First Search Algorithm)是一种图形搜索算法，用于在图形或树中遍历或搜索数据结构。
其基本思路是从根节点开始扫描整个图，按照层次顺序依次访问每个节点，每一层访问完后才会进入下一层。
例如，在寻找从起点到终点的最短路径时，广度优先搜索算法是一种有效的方法。具体来说，该算法首先将起点加入队列中，然后从队列中取出第一个节点，扫描该节点的所有邻居节点并将其加入队列中，然后重复这个过程，直到找到终点或者队列为空为止。
以下是两个完整的例子：
示例1：在一个图中查找最短路径
# 定义一个有向图，使用邻接表表示法
graph = {1: [2, 3], 2: [4, 5], 3: [4, 6], 4: [6], 5: [4], 6: []}
# 定义起点和终点
start = 1
end = 6
# 定义一个队列，用于存储遍历的节点
queue = []
# 定义一个标记数组，标记节点是否已经被遍历过
visited = [0] * (len(graph) + 1)
# 将起点加入队列中
queue.append(start)
visited[start] = 1
# 定义一个字典，用于记录每个节点的前一个节点，最终用于查找最短路径
prev = {start: None}
# 广度优先搜索
while queue:
node = queue.pop(0)
for neighbor in graph[node]:
if not visited[neighbor]:
queue.append(neighbor)
visited[neighbor] = 1
prev[neighbor] = node
if neighbor == end:
path = []
while node:
path.append(node)
node = prev[node]
print('最短路径为：', path[::-1])
break
示例2：在一个迷宫中查找最短路径
# 定义一个迷宫地图
maze = [
[0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[1, 1, 1, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 1, 0]
]
# 定义起点和终点
start = (0, 0)
end = (6, 6)
# 定义一个队列，用于存储遍历的节点
queue = []
# 定义一个标记数组，标记节点是否已经被遍历过
visited = [[0] * 7 for _ in range(7)]
# 定义一个字典，用于记录每个节点的前一个节点，最终用于查找最短路径
prev = {start: None}
# 广度优先搜索
queue.append(start)
visited[start[0]][start[1]] = 1
row_nums = [-1, 0, 1, 0]
col_nums = [0, 1, 0, -1]
while queue:
node = queue.pop(0)
for i in range(4):
row = node[0] + row_nums[i]
col = node[1] + col_nums[i]
if 0 <= row < len(maze) and 0 <= col < len(maze[0]) and not visited[row][col] and maze[row][col] == 0:
queue.append((row, col))
visited[row][col] = 1
prev[(row, col)] = node
if (row, col) == end:
path = [(row, col)]
while node:
path.append(node)
node = prev[node]
print('最短路径为：', path[::-1])
break
以上两个例子都是使用广度优先搜索算法找到了起点到终点的最短路径。其中，第一个例子是在一个有向图中查找最短路劲，第二个例子是在一个二维数组迷宫中查找最短路径。
广度优先搜索算法(Breadth-First Search Algorithm)是一种图形搜索算法，用于在图形或树中遍历或搜索数据结构。
其基本思路是从根节点开始扫描整个图，按照层次顺序依次访问每个节点，每一层访问完后才会进入下一层。
例如，在寻找从起点到终点的最短路径时，广度优先搜索算法是一种有效的方法。具体来说，该算法首先将起点加入队列中，然后从队列中取出第一个节点，扫描该节点的所有邻居节点并将其加入队列中，然后重复这个过程，直到找到终点或者队列为空为止。
以下是两个完整的例子：
示例1：在一个图中查找最短路径
# 定义一个有向图，使用邻接表表示法
graph = {1: [2, 3], 2: [4, 5], 3: [4, 6], 4: [6], 5: [4], 6: []}
# 定义起点和终点
start = 1
end = 6
# 定义一个队列，用于存储遍历的节点
queue = []
# 定义一个标记数组，标记节点是否已经被遍历过
visited = [0] * (len(graph) + 1)
# 将起点加入队列中
queue.append(start)
visited[start] = 1
# 定义一个字典，用于记录每个节点的前一个节点，最终用于查找最短路径
prev = {start: None}
# 广度优先搜索
while queue:
node = queue.pop(0)
for neighbor in graph[node]:
if not visited[neighbor]:
queue.append(neighbor)
visited[neighbor] = 1
prev[neighbor] = node
if neighbor == end:
path = []
while node:
path.append(node)
node = prev[node]
print('最短路径为：', path[::-1])
break
示例2：在一个迷宫中查找最短路径
# 定义一个迷宫地图
maze = [
[0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[1, 1, 1, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 1, 0]
]
# 定义起点和终点
start = (0, 0)
end = (6, 6)
# 定义一个队列，用于存储遍历的节点
queue = []
# 定义一个标记数组，标记节点是否已经被遍历过
visited = [[0] * 7 for _ in range(7)]
# 定义一个字典，用于记录每个节点的前一个节点，最终用于查找最短路径
prev = {start: None}
# 广度优先搜索
queue.append(start)
visited[start[0]][start[1]] = 1
row_nums = [-1, 0, 1, 0]
col_nums = [0, 1, 0, -1]
while queue:
node = queue.pop(0)
for i in range(4):
row = node[0] + row_nums[i]
col = node[1] + col_nums[i]
if 0 <= row < len(maze) and 0 <= col < len(maze[0]) and not visited[row][col] and maze[row][col] == 0:
queue.append((row, col))
visited[row][col] = 1
prev[(row, col)] = node
if (row, col) == end:
path = [(row, col)]
while node:
path.append(node)
node = prev[node]
print('最短路径为：', path[::-1])
break
以上两个例子都是使用广度优先搜索算法找到了起点到终点的最短路径。其中，第一个例子是在一个有向图中查找最短路劲，第二个例子是在一个二维数组迷宫中查找最短路径。