Forgetting null/base-case handling
Wrong move: Recursive traversal assumes children always exist.
Usually fails on: Leaf nodes throw errors or create wrong depth/path values.
Fix: Handle null/base cases before recursive transitions.
Move from brute-force thinking to an efficient approach using tree strategy.
Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.
Return the smallest level x such that the sum of all the values of nodes at level x is maximal.
Example 1:
Input: root = [1,7,0,7,-8,null,null] Output: 2 Explanation: Level 1 sum = 1. Level 2 sum = 7 + 0 = 7. Level 3 sum = 7 + -8 = -1. So we return the level with the maximum sum which is level 2.
Example 2:
Input: root = [989,null,10250,98693,-89388,null,null,null,-32127] Output: 2
Constraints:
[1, 104].-105 <= Node.val <= 105Problem summary: Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on. Return the smallest level x such that the sum of all the values of nodes at level x is maximal.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Tree
[1,7,0,7,-8,null,null]
[989,null,10250,98693,-89388,null,null,null,-32127]
kth-largest-sum-in-a-binary-tree)cousins-in-binary-tree-ii)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #1161: Maximum Level Sum of a Binary Tree
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int maxLevelSum(TreeNode root) {
Deque<TreeNode> q = new ArrayDeque<>();
q.offer(root);
int mx = Integer.MIN_VALUE;
int i = 0;
int ans = 0;
while (!q.isEmpty()) {
++i;
int s = 0;
for (int n = q.size(); n > 0; --n) {
TreeNode node = q.pollFirst();
s += node.val;
if (node.left != null) {
q.offer(node.left);
}
if (node.right != null) {
q.offer(node.right);
}
}
if (mx < s) {
mx = s;
ans = i;
}
}
return ans;
}
}
// Accepted solution for LeetCode #1161: Maximum Level Sum of a Binary Tree
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func maxLevelSum(root *TreeNode) int {
q := []*TreeNode{root}
mx := -0x3f3f3f3f
i := 0
ans := 0
for len(q) > 0 {
i++
s := 0
for n := len(q); n > 0; n-- {
root = q[0]
q = q[1:]
s += root.Val
if root.Left != nil {
q = append(q, root.Left)
}
if root.Right != nil {
q = append(q, root.Right)
}
}
if mx < s {
mx = s
ans = i
}
}
return ans
}
# Accepted solution for LeetCode #1161: Maximum Level Sum of a Binary Tree
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def maxLevelSum(self, root: Optional[TreeNode]) -> int:
q = deque([root])
mx = -inf
i = 0
while q:
i += 1
s = 0
for _ in range(len(q)):
node = q.popleft()
s += node.val
if node.left:
q.append(node.left)
if node.right:
q.append(node.right)
if mx < s:
mx = s
ans = i
return ans
// Accepted solution for LeetCode #1161: Maximum Level Sum of a Binary Tree
// Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
// pub val: i32,
// pub left: Option<Rc<RefCell<TreeNode>>>,
// pub right: Option<Rc<RefCell<TreeNode>>>,
// }
//
// impl TreeNode {
// #[inline]
// pub fn new(val: i32) -> Self {
// TreeNode {
// val,
// left: None,
// right: None
// }
// }
// }
use std::cell::RefCell;
use std::rc::Rc;
use std::collections::VecDeque;
impl Solution {
pub fn max_level_sum(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
let mut q = VecDeque::new();
if let Some(r) = root {
q.push_back(r);
}
let mut i = 0;
let mut mx = i32::MIN;
let mut ans = 0;
while !q.is_empty() {
i += 1;
let mut s = 0;
let sz = q.len();
for _ in 0..sz {
let node = q.pop_front().unwrap();
let node = node.borrow();
s += node.val;
if let Some(left) = node.left.clone() {
q.push_back(left);
}
if let Some(right) = node.right.clone() {
q.push_back(right);
}
}
if s > mx {
mx = s;
ans = i;
}
}
ans
}
}
// Accepted solution for LeetCode #1161: Maximum Level Sum of a Binary Tree
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function maxLevelSum(root: TreeNode | null): number {
let q = [root];
let i = 0;
let mx = -Infinity;
let ans = 0;
while (q.length) {
++i;
const nq = [];
let s = 0;
for (const { val, left, right } of q) {
s += val;
left && nq.push(left);
right && nq.push(right);
}
if (mx < s) {
mx = s;
ans = i;
}
q = nq;
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
BFS with a queue visits every node exactly once — O(n) time. The queue may hold an entire level of the tree, which for a complete binary tree is up to n/2 nodes = O(n) space. This is optimal in time but costly in space for wide trees.
Every node is visited exactly once, giving O(n) time. Space depends on tree shape: O(h) for recursive DFS (stack depth = height h), or O(w) for BFS (queue width = widest level). For balanced trees h = log n; for skewed trees h = n.
Review these before coding to avoid predictable interview regressions.
Wrong move: Recursive traversal assumes children always exist.
Usually fails on: Leaf nodes throw errors or create wrong depth/path values.
Fix: Handle null/base cases before recursive transitions.