chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-01-06-1161-Maximum-Level-Sum-of-a-Binary-Tree/explanation.md

@@ -0,0 +1,31 @@
+# Maximum Level Sum of a Binary Tree (Medium)
+
+**Problem ID:** 1161  
+**Date:** 2026-01-06  
+**Link:** https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/
+
+## Approach
+
+To solve the problem of finding the smallest level in a binary tree with the maximum sum of node values, we can utilize a breadth-first search (BFS) approach. Here’s a concise breakdown of the approach:
+
+### Main Idea:
+The goal is to traverse the binary tree level by level, calculate the sum of node values at each level, and keep track of the maximum sum encountered. We also need to ensure that if multiple levels have the same maximum sum, we return the smallest level.
+
+### Approach:
+1. **BFS Traversal**: Use a queue to perform a level-order traversal of the binary tree. This allows us to process each level of the tree one at a time.
+  
+2. **Level Sum Calculation**: For each level, initialize a sum variable to zero. As we dequeue nodes from the queue, add their values to this sum. Also, enqueue their children (if they exist) for processing in the next level.
+
+3. **Tracking Maximum Sum**: Maintain variables to track the maximum sum found (`max_sum`) and the corresponding level (`max_level`). After processing each level, compare the current level's sum with `max_sum`. If the current sum exceeds `max_sum`, update both `max_sum` and `max_level`. If it equals `max_sum`, do not update `max_level` since we want the smallest level.
+
+4. **Return Result**: Once all levels are processed, return `max_level`, which will hold the smallest level with the maximum sum.
+
+### Data Structures:
+- A queue (FIFO) to facilitate the level-order traversal.
+- Variables to store the current level sum, maximum sum, and the level corresponding to the maximum sum.
+
+### Complexity:
+- **Time Complexity**: O(N), where N is the number of nodes in the tree. Each node is processed exactly once.
+- **Space Complexity**: O(W), where W is the maximum width of the tree. In the worst case, this is O(N) for a completely unbalanced tree, but typically it will be less.
+
+This approach efficiently computes the desired level while ensuring clarity and simplicity in the traversal and summation process.

Medium/2026-01-06-1161-Maximum-Level-Sum-of-a-Binary-Tree/solution.java

@@ -0,0 +1,44 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Solution {
+    public int maxLevelSum(TreeNode root) {
+        if (root == null) return 0;
+
+        int maxSum = Integer.MIN_VALUE;
+        int maxLevel = 1;
+        int currentLevel = 1;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size();
+            int currentSum = 0;
+
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode node = queue.poll();
+                currentSum += node.val;
+
+                if (node.left != null) queue.offer(node.left);
+                if (node.right != null) queue.offer(node.right);
+            }
+
+            if (currentSum > maxSum) {
+                maxSum = currentSum;
+                maxLevel = currentLevel;
+            }
+
+            currentLevel++;
+        }
+
+        return maxLevel;
+    }
+}
+
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    TreeNode(int x) { val = x; }
+}

Medium/2026-01-06-1161-Maximum-Level-Sum-of-a-Binary-Tree/solution.js

@@ -0,0 +1,37 @@
+class TreeNode {
+    constructor(val, left = null, right = null) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}
+
+var maxLevelSum = function(root) {
+    if (!root) return 0;
+
+    let queue = [root];
+    let maxSum = -Infinity;
+    let level = 0;
+    let resultLevel = 0;
+
+    while (queue.length > 0) {
+        level++;
+        let levelSum = 0;
+        let levelSize = queue.length;
+
+        for (let i = 0; i < levelSize; i++) {
+            let node = queue.shift();
+            levelSum += node.val;
+
+            if (node.left) queue.push(node.left);
+            if (node.right) queue.push(node.right);
+        }
+
+        if (levelSum > maxSum) {
+            maxSum = levelSum;
+            resultLevel = level;
+        }
+    }
+
+    return resultLevel;
+};

Medium/2026-01-06-1161-Maximum-Level-Sum-of-a-Binary-Tree/solution.py

@@ -0,0 +1,39 @@
+# 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: TreeNode) -> int:
+        from collections import deque
+        
+        if not root:
+            return 0
+        
+        queue = deque([root])
+        max_sum = float('-inf')
+        max_level = 1
+        current_level = 1
+        
+        while queue:
+            level_sum = 0
+            level_size = len(queue)
+            
+            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
+            
+            current_level += 1
+        
+        return max_level

README.md

@@ -327,3 +327,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-03 — [Number of Ways to Paint N × 3 Grid](https://leetcode.com/problems/number-of-ways-to-paint-n-3-grid/) (Hard) → `Hard/2026-01-03-1411-Number-of-Ways-to-Paint-N-3-Grid`
 - 2026-01-04 — [Four Divisors](https://leetcode.com/problems/four-divisors/) (Medium) → `Medium/2026-01-04-1390-Four-Divisors`
 - 2026-01-05 — [Maximum Matrix Sum](https://leetcode.com/problems/maximum-matrix-sum/) (Medium) → `Medium/2026-01-05-1975-Maximum-Matrix-Sum`
+- 2026-01-06 — [Maximum Level Sum of a Binary Tree](https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/) (Medium) → `Medium/2026-01-06-1161-Maximum-Level-Sum-of-a-Binary-Tree`