1/**
2 * Definition for a binary tree node.
3 */
4public class TreeNode {
5    int val;
6    TreeNode left;
7    TreeNode right;
8  
9    TreeNode() {}
10
11    TreeNode(int val) {
12        this.val = val;
13    }
14
15    TreeNode(int val, TreeNode left, TreeNode right) {
16        this.val = val;
17        this.left = left;
18        this.right = right;
19    }
20}
21
22class Solution {
23    public int minimumLevel(TreeNode root) {
24        // Initialize a queue to perform level order traversal
25        Deque<TreeNode> queue = new ArrayDeque<>();
26        queue.offer(root);
27
28        int minLevel = 0;
29        long minSum = Long.MAX_VALUE;
30
31        // Perform BFS to traverse each level of the tree
32        for (int currentLevel = 1; !queue.isEmpty(); ++currentLevel) {
33            long currentSum = 0;
34            int nodesAtCurrentLevel = queue.size();
35
36            // Process all nodes at the current level
37            for (int i = 0; i < nodesAtCurrentLevel; ++i) {
38                TreeNode node = queue.poll();
39                currentSum += node.val;
40
41                // Add left and right children to the queue if they exist
42                if (node.left != null) {
43                    queue.offer(node.left);
44                }
45                if (node.right != null) {
46                    queue.offer(node.right);
47                }
48            }
49
50            // Update minimum sum and level if current level sum is smaller
51            if (currentSum < minSum) {
52                minSum = currentSum;
53                minLevel = currentLevel;
54            }
55        }
56
57        return minLevel; // Return the level with the minimum sum
58    }
59}
60

1#include <queue>
2#include <climits>
3
4// Definition for a binary tree node.
5struct TreeNode {
6    int val;                      // Value of the node
7    TreeNode* left;               // Pointer to the left child
8    TreeNode* right;              // Pointer to the right child
9    TreeNode() : val(0), left(nullptr), right(nullptr) {}                         // Default constructor
10    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}                    // Constructor with value
11    TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {} // Constructor with value, left and right child
12};
13
14class Solution {
15public:
16    int minimumLevel(TreeNode* root) {
17        if (!root) return 0; // If the root is null, return 0 as there are no levels
18
19        std::queue<TreeNode*> nodeQueue; // Queue to perform level-order traversal
20        nodeQueue.push(root);            // Start with the root node
21
22        int ans = 0;                      // To store the level with the minimum sum
23        long long minSum = LLONG_MAX;     // Initialize minSum with a large value (maximum possible long long value)
24
25        for (int level = 1; !nodeQueue.empty(); ++level) {
26            long long levelSum = 0; // To store the sum of values at the current level
27            int count = nodeQueue.size(); // Number of nodes in the current level
28
29            // Iterate over all nodes in the current level
30            for (int i = 0; i < count; ++i) {
31                TreeNode* node = nodeQueue.front();
32                nodeQueue.pop();
33                levelSum += node->val;   // Add the node's value to the level's sum
34
35                // Push the left and right children to the queue if they exist
36                if (node->left) {
37                    nodeQueue.push(node->left);
38                }
39                if (node->right) {
40                    nodeQueue.push(node->right);
41                }
42            }
43
44            // If the current level's sum is less than the recorded minimum sum, update it
45            if (levelSum < minSum) {
46                minSum = levelSum;
47                ans = level;
48            }
49        }
50
51        return ans; // Return the level which has the minimum sum
52    }
53};
54

1// TypeScript function to find the level with the minimum sum in a binary tree.
2// The TreeNode interface represents a node in a binary tree.
3interface TreeNode {
4    val: number;
5    left: TreeNode | null;
6    right: TreeNode | null;
7}
8
9// Function to determine the level with the smallest sum of values in the binary tree.
10function minimumLevel(root: TreeNode | null): number {
11    // Initialize a queue with the root node for level order traversal.
12    const q: TreeNode[] = [root];
13    // Initialize the smallest sum seen so far to Infinity, and the answer to level 0.
14    let s = Infinity;
15    let ans = 0;
16
17    // Traverse level by level until the queue is empty.
18    for (let level = 1; q.length; ++level) {
19        const qq: TreeNode[] = []; // Temporary queue for the next level.
20        let t = 0; // Sum of the current level.
21
22        // Traverse nodes of the current level.
23        for (const { val, left, right } of q) {
24            t += val; // Add the value of the current node to the sum of the level.
25            left && qq.push(left);  // If there is a left child, add it to the next level queue.
26            right && qq.push(right); // If there is a right child, add it to the next level queue.
27        }
28
29        // If the current level sum is less than the smallest sum recorded, update the smallest sum and answer.
30        if (s > t) {
31            s = t;
32            ans = level;
33        }
34
35        // Replace the current queue with the next level queue.
36        q.splice(0, q.length, ...qq);
37    }
38
39    // Return the level with the minimum sum.
40    return ans;
41}
42