LeetCode 1161题解：二叉树最大层和BFS实现

1. 题目解析与核心思路

LeetCode 1161题要求我们找到二叉树中元素和最大的那一层，如果有多个层的和相同，则返回层号最小的那个。这道题被标记为中等难度，主要考察对二叉树的遍历和层级统计能力。

从题目描述来看，我们需要解决两个关键问题：

1. 如何按层遍历二叉树
2. 如何计算每层的元素和并找出最大值

1.1 二叉树层序遍历的选择

对于层序遍历，我们通常有两种选择：

• 广度优先搜索(BFS)：使用队列实现，天然适合按层处理
• 深度优先搜索(DFS)：需要额外记录层级信息

在本题场景下，BFS是更自然的选择，因为：

• 它按层处理节点的特性与题目需求完美契合
• 不需要额外的层级标记
• 代码实现更直观易懂

1.2 算法框架设计

基于BFS的标准层序遍历框架，我们需要：

1. 初始化队列，通常包含根节点
2. 维护当前层号和层和变量
3. 在每层遍历时：
   • 记录本层节点数量(队列长度)
   • 处理完固定数量的节点后进入下一层
4. 比较并更新最大层和

2. 详细实现与代码解析

2.1 Python实现代码

python复制from collections import deque

class Solution:
    def maxLevelSum(self, root: TreeNode) -> int:
        if not root:
            return 0
            
        max_sum = float('-inf')
        max_level = 1
        current_level = 1
        
        queue = deque([root])
        
        while queue:
            level_size = len(queue)
            level_sum = 0
            
            for _ in range(level_size):
                node = queue.popleft()
                level_sum += node.val
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            if level_sum > max_sum:
                max_sum = level_sum
                max_level = current_level
            elif level_sum == max_sum and current_level < max_level:
                max_level = current_level
                
            current_level += 1
            
        return max_level

2.2 关键代码段解析

1. 队列初始化：

   python复制queue = deque([root])
   

   使用双端队列实现BFS，初始时只包含根节点

2. 层处理循环：

   python复制level_size = len(queue)
   for _ in range(level_size):
   

   记录当前层的节点数量，确保只处理本层节点

3. 节点处理：

   python复制node = queue.popleft()
   level_sum += node.val
   

   取出节点并累加值，同时将其子节点加入队列

4. 结果更新：

   python复制if level_sum > max_sum:
       max_sum = level_sum
       max_level = current_level
   elif level_sum == max_sum and current_level < max_level:
       max_level = current_level
   

   比较并更新最大层和，处理层号更小的情况

3. 复杂度分析与优化

3.1 时间复杂度

• 每个节点被访问一次：O(N)
• 每个节点被队列操作两次(入队和出队)：O(1)每次操作
• 总体时间复杂度：O(N)

3.2 空间复杂度

• 最坏情况下队列存储最后一层节点：O(N)
• 平均情况下取决于树的平衡性

3.3 可能的优化方向

1. DFS实现：

   • 使用递归或栈实现
   • 需要额外维护层级信息
   • 代码可能更简洁但不如BFS直观

2. 提前终止：

   • 如果能够确定后续层和不可能超过当前最大值
   • 但在一般情况下难以实现

4. 边界条件与测试用例

4.1 重要边界情况

1. 空树：应返回0
2. 单节点树：返回1
3. 所有层和相同：返回最小层号
4. 负数值节点：确保比较逻辑正确
5. 大数相加：注意不会溢出(Python无此问题)

4.2 示例测试用例

python复制def test_maxLevelSum():
    # 测试用例1：常规情况
    #       1
    #      / \
    #     7   0
    #    / \
    #   7  -8
    root1 = TreeNode(1)
    root1.left = TreeNode(7)
    root1.right = TreeNode(0)
    root1.left.left = TreeNode(7)
    root1.left.right = TreeNode(-8)
    assert Solution().maxLevelSum(root1) == 2
    
    # 测试用例2：单节点
    root2 = TreeNode(100)
    assert Solution().maxLevelSum(root2) == 1
    
    # 测试用例3：空树
    assert Solution().maxLevelSum(None) == 0
    
    # 测试用例4：多层相同和
    #       1
    #      / \
    #     2   3
    root4 = TreeNode(1)
    root4.left = TreeNode(2)
    root4.right = TreeNode(3)
    assert Solution().maxLevelSum(root4) == 2

5. 常见问题与解决技巧

5.1 为什么我的层号计算不正确？

常见错误：

1. 在节点处理循环外更新层号
2. 没有正确处理空树情况
3. 层号初始化错误(应该从1开始)

解决方案：

• 确保层号只在处理完整个层后递增
• 添加空树检查
• 明确初始化max_level和current_level为1

5.2 如何处理相同和的情况？

题目要求当多个层和相同时返回最小的层号。实现时：

1. 只有在当前和大于max_sum时才更新
2. 当和相等时，只有当前层号更小才更新

5.3 BFS与DFS的选择考量

虽然DFS也能解决，但：

• BFS更符合直觉，代码更易维护
• DFS需要维护层级映射，可能使用更多内存
• 面试中通常期望BFS解法

6. 扩展思考与类似题目

6.1 相关题目推荐

1. LeetCode 102. 二叉树的层序遍历
2. LeetCode 107. 二叉树的层序遍历 II
3. LeetCode 103. 二叉树的锯齿形层序遍历
4. LeetCode 199. 二叉树的右视图

6.2 实际应用场景

这种层级统计的思想可以应用于：

1. 组织结构图分析
2. 游戏中的关卡设计
3. 网络拓扑中的层级分析
4. 社交网络中的关系度统计

6.3 算法变种思考

如果题目改为：

1. 找层内元素平均值最大的层
2. 找层内元素乘积最大的层
3. 找层内满足某种条件的节点最多的层

这些变种都可以基于相同的BFS框架，只需修改统计逻辑即可。