编程新手必备：用DFS和BFS破解LeetCode难题

作为一名初出茅庐的程序员，踏上算法学习的道路时，LeetCode无疑是必经的修行场。而DFS（深度优先搜索）和BFS（广度优先搜索）作为两大搜索算法，更可谓是LeetCode刷题中绕不开的坎儿。

深度优先搜索（DFS）

DFS的过程就像在一个迷宫中探索。它从一个节点开始，不断深入探索，直至走不通为止，再回溯到上一个节点继续探索。DFS的优点在于，可以深入探索每一条路径，更易于找到最优解。

广度优先搜索（BFS）

BFS的过程则更像是波浪式前进。它从一个节点开始，将该节点的所有相邻节点都纳入队列，再依次探索队列中的所有节点，直到队列为空为止。BFS的优点在于，可以更全面地搜索所有节点，不易错过任何解。

算法指南

现在，让我们通过具体的LeetCode题目来理解DFS和BFS的实际应用。

LeetCode 103：二叉树的锯齿形层序遍历

DFS实现：

def zigzagLevelOrder(root):
    res = []
    level = 0
    dfs(root, level, res)
    return res

def dfs(root, level, res):
    if not root:
        return
    
    if level >= len(res):
        res.append([])
    
    if level % 2 == 0:
        res[level].append(root.val)
    else:
        res[level].insert(0, root.val)
    
    dfs(root.left, level + 1, res)
    dfs(root.right, level + 1, res)

BFS实现：

def zigzagLevelOrder(root):
    if not root:
        return []
    
    res = []
    queue = [root]
    level = 0
    
    while queue:
        size = len(queue)
        level_res = []
        
        for i in range(size):
            node = queue.pop(0)
            if level % 2 == 0:
                level_res.append(node.val)
            else:
                level_res.insert(0, node.val)
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        res.append(level_res)
        level += 1
    
    return res

LeetCode 199：二叉树的右视图

DFS实现：

def rightSideView(root):
    if not root:
        return []
    
    max_level = 0
    res = []
    dfs(root, 1, max_level, res)
    return res

def dfs(root, level, max_level, res):
    if not root:
        return
    
    if level > max_level:
        res.append(root.val)
        max_level = level
    
    dfs(root.right, level + 1, max_level, res)
    dfs(root.left, level + 1, max_level, res)

BFS实现：

def rightSideView(root):
    if not root:
        return []
    
    res = []
    queue = [root]
    
    while queue:
        size = len(queue)
        last_val = None
        
        for i in range(size):
            node = queue.pop(0)
            last_val = node.val
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        res.append(last_val)
    
    return res

LeetCode 542：01 矩阵

BFS实现：

def updateMatrix(matrix):
    if not matrix:
        return []
    
    m, n = len(matrix), len(matrix[0])
    res = [[0] * n for _ in range(m)]
    queue = [(i, j) for i in range(m) for j in range(n) if matrix[i][j] == 0]
    
    while queue:
        i, j = queue.pop(0)
        
        for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
            x, y = i + dx, j + dy
            if 0 <= x < m and 0 <= y < n and res[x][y] == 0:
                res[x][y] = res[i][j] + 1
                queue.append((x, y))
    
    return res

结语

DFS和BFS算法作为两把算法利刃，在解决LeetCode难题时可谓游刃有余。理解它们背后的原理和应用场景，将大大提升你的算法技能和刷题效率。