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 <= 105The BFS approach is well-suited for problems involving levels of a binary tree. We will use a queue to process the tree level by level, keeping track of the sum of node values at each level. We will maintain a variable to store the maximum sum encountered and the level corresponding to this maximum sum. By processing level by level, we ensure that when we find a new maximum, it is the smallest level with that sum.
This implementation uses a queue to traverse the binary tree level by level. For each level, we calculate the sum of its node values. If this sum is greater than the previously recorded maximum sum, we update the maximum sum and note the level number. The queue helps ensure that each node of a given level is processed before nodes of the next level, which is key to implementing BFS.
C++
Java
Python
C#
JavaScript
Time Complexity: O(n), where n is the number of nodes in the tree, because each node is enqueued and dequeued exactly once.
Space Complexity: O(m), where m is the maximum number of nodes at any level in the tree, due to the queue holding nodes of a single level.
This approach involves using a DFS traversal to explore the tree. We pass the current depth as a parameter to each recursive call and maintain an array or dictionary to track the sum of values at each level. After the traversal, we determine which level has the highest sum. DFS allows us to explore the tree deeply, and since each call carries a depth count, we can easily track levels.
The Python solution uses DFS by recursively traversing the tree and tracking the sum of node values at each level using a dictionary. After completing the traversal, it identifies the level with the maximum sum.
Time Complexity: O(n)
Space Complexity: O(d), where d is the maximum depth of the tree (related to recursion stack depth and level count in the dictionary).
| Approach | Complexity |
|---|---|
| Breadth-First Search (BFS) Approach | Time Complexity: O(n), where n is the number of nodes in the tree, because each node is enqueued and dequeued exactly once. |
| Depth-First Search (DFS) with Level Tracking | Time Complexity: O(n) |
Maximum Level Sum of a Binary Tree | Leetcode-1161 | AMAZON | Explanation ➕ Live Coding • codestorywithMIK • 4,375 views views
Watch 9 more video solutions →Practice Maximum Level Sum of a Binary Tree with our built-in code editor and test cases.
Practice on FleetCode