Daily LeetCode - by Vítor Belim

Description

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:

The number of nodes in the tree is in the range [1, 10⁴].
-10⁵ <= Node.val <= 10⁵

Solutions

This solution finds the tree level with the largest sum of node values in two phases. First, a recursive depth-first search (dfs) visits every node while carrying its level (starting at 1 for the root), and a Map keeps a running total per level — the expression (map.get(level) || 0) + node.val adds each node's value to its level's sum, defaulting to 0 the first time a level is seen. Second, a while loop scans the levels in ascending order using map.has(level), updating max and maxLvl whenever a level's sum is strictly greater than the best so far, which guarantees the smallest such level wins ties. Crucially, max starts at -Infinity, so the comparison works correctly even when all level sums are negative — the fix that makes this attempt pass where the previous one failed.

Language: javascript(2026-01-06 09:07)DONE

CPU Performance74.73%

Memory Performance36.02%

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxLevelSum = function(root) {
    const map = new Map();

    const dfs = (node, level) => {
        if (!node) return;

        map.set(level, (map.get(level) || 0) + node.val);

        dfs(node.left, level + 1);
        dfs(node.right, level + 1);
    };

    dfs(root, 1);

    let level = 1;
    let max = -Infinity;
    let maxLvl = 1;

    while (map.has(level)) {
        const count = map.get(level);

        if (count > max) {
            max = count;
            maxLvl = level;
        }

        level++;
    }

    return maxLvl;
};

Description

Solutions

AI Explanation