python 经典算法之--深度优先搜索算法(Depth-First Search Algorithm)
深度优先搜索算法，也称为DFS算法，是一种遍历图或树的搜索算法，它先沿着一条路径一直走到底，然后回溯到上一个节点，继续沿着另一条路径走到底，直到所有节点都被遍历。DFS算法的特点是需要使用栈来辅助实现递归，可以用递归或非递归的方式实现。
下面举两个完整的例子说明DFS算法的实现。
例子1：二叉树的深度优先搜索
对于一个二叉树，我们可以使用深度优先搜索算法来遍历它的节点。我们可以使用递归实现DFS算法，也可以使用栈来辅助实现递归。
# 定义二叉树节点类
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
# 递归实现深度优先搜索
def dfs_recursive(node):
if not node:
return
print(node.val) # 打印节点值
dfs_recursive(node.left) # 遍历左子树
dfs_recursive(node.right) # 遍历右子树
# 非递归实现深度优先搜索
def dfs_iterative(root):
if not root:
return
stack = [root] # 定义栈，把根节点入栈
while stack:
node = stack.pop() # 获取栈顶节点
print(node.val) # 打印节点值
if node.right: # 将右子节点入栈
stack.append(node.right)
if node.left: # 将左子节点入栈
stack.append(node.left)
# 测试
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
print("递归实现深度优先搜索：")
dfs_recursive(root)
print("非递归实现深度优先搜索：")
dfs_iterative(root)
例子2：迷宫问题的深度优先搜索
假设有一个迷宫问题，我们需要通过深度优先搜索算法来找到从起点到终点的路径。迷宫是一个二维矩阵，其中0表示可以通过，1表示障碍物不可通过。我们使用DFS算法递归遍历所有可能的路径，在遍历的过程中记录路径，直到找到终点。
# 定义迷宫问题类
class Maze:
def __init__(self, matrix):
self.matrix = matrix
self.rows = len(matrix)
self.cols = len(matrix[0])
self.result = [] # 记录路径
# 深度优先搜索
def dfs(self, x, y):
if x < 0 or y < 0 or x >= self.rows or y >= self.cols or self.matrix[x][y] == 1:
return False
if [x, y] in self.result:
return False
self.result.append([x, y])
if x == self.rows-1 and y == self.cols-1:
return True
if self.dfs(x+1, y) or self.dfs(x, y+1) or self.dfs(x-1, y) or self.dfs(x, y-1):
return True
self.result.pop()
return False
# 输出结果
def print_result(self):
if not self.result:
print("无解")
return
for step in self.result:
print(step)
# 测试
matrix = [[0, 1, 0, 0],
[0, 0, 0, 1],
[0, 1, 0, 0],
[0, 0, 1, 0]]
maze = Maze(matrix)
if maze.dfs(0, 0):
maze.print_result()
else:
print("无解")
以上就是两个完整的例子，展示了DFS算法的实现和应用。
深度优先搜索算法，也称为DFS算法，是一种遍历图或树的搜索算法，它先沿着一条路径一直走到底，然后回溯到上一个节点，继续沿着另一条路径走到底，直到所有节点都被遍历。DFS算法的特点是需要使用栈来辅助实现递归，可以用递归或非递归的方式实现。
下面举两个完整的例子说明DFS算法的实现。
例子1：二叉树的深度优先搜索
对于一个二叉树，我们可以使用深度优先搜索算法来遍历它的节点。我们可以使用递归实现DFS算法，也可以使用栈来辅助实现递归。
# 定义二叉树节点类
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
# 递归实现深度优先搜索
def dfs_recursive(node):
if not node:
return
print(node.val) # 打印节点值
dfs_recursive(node.left) # 遍历左子树
dfs_recursive(node.right) # 遍历右子树
# 非递归实现深度优先搜索
def dfs_iterative(root):
if not root:
return
stack = [root] # 定义栈，把根节点入栈
while stack:
node = stack.pop() # 获取栈顶节点
print(node.val) # 打印节点值
if node.right: # 将右子节点入栈
stack.append(node.right)
if node.left: # 将左子节点入栈
stack.append(node.left)
# 测试
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
print("递归实现深度优先搜索：")
dfs_recursive(root)
print("非递归实现深度优先搜索：")
dfs_iterative(root)
例子2：迷宫问题的深度优先搜索
假设有一个迷宫问题，我们需要通过深度优先搜索算法来找到从起点到终点的路径。迷宫是一个二维矩阵，其中0表示可以通过，1表示障碍物不可通过。我们使用DFS算法递归遍历所有可能的路径，在遍历的过程中记录路径，直到找到终点。
# 定义迷宫问题类
class Maze:
def __init__(self, matrix):
self.matrix = matrix
self.rows = len(matrix)
self.cols = len(matrix[0])
self.result = [] # 记录路径
# 深度优先搜索
def dfs(self, x, y):
if x < 0 or y < 0 or x >= self.rows or y >= self.cols or self.matrix[x][y] == 1:
return False
if [x, y] in self.result:
return False
self.result.append([x, y])
if x == self.rows-1 and y == self.cols-1:
return True
if self.dfs(x+1, y) or self.dfs(x, y+1) or self.dfs(x-1, y) or self.dfs(x, y-1):
return True
self.result.pop()
return False
# 输出结果
def print_result(self):
if not self.result:
print("无解")
return
for step in self.result:
print(step)
# 测试
matrix = [[0, 1, 0, 0],
[0, 0, 0, 1],
[0, 1, 0, 0],
[0, 0, 1, 0]]
maze = Maze(matrix)
if maze.dfs(0, 0):
maze.print_result()
else:
print("无解")
以上就是两个完整的例子，展示了DFS算法的实现和应用。