# Sum of leaf nodes at minimum level

• Difficulty Level : Easy
• Last Updated : 12 May, 2022

Given a binary tree containing n nodes. The problem is to get the sum of all the leaf nodes which are at minimum level in the binary tree.
Examples:

```Input :
1
/   \
2     3
/  \   /  \
4   5   6   7
/     \
8       9

Output : 11
Leaf nodes 4 and 7 are at minimum level.
Their sum = (4 + 7) = 11. ```

Approach: Perform iterative level order traversal using queue and find the first level containing a leaf node. Sum up all the leaf nodes at this level and then stop performing the traversal further.

## C++

 `// C++ implementation to find the sum of` `// leaf nodes at minimum level` `#include ` `using` `namespace` `std;`   `// structure of a node of binary tree` `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `};`   `// function to get a new node` `Node* getNode(``int` `data)` `{` `    ``// allocate space` `    ``Node* newNode = (Node*)``malloc``(``sizeof``(Node));`   `    ``// put in the data` `    ``newNode->data = data;` `    ``newNode->left = newNode->right = NULL;` `    ``return` `newNode;` `}`   `// function to find the sum of` `// leaf nodes at minimum level` `int` `sumOfLeafNodesAtMinLevel(Node* root)` `{` `    ``// if tree is empty` `    ``if` `(!root)` `        ``return` `0;`   `    ``// if there is only one node` `    ``if` `(!root->left && !root->right)` `        ``return` `root->data;`   `    ``// queue used for level order traversal` `    ``queue q;` `    ``int` `sum = 0; ` `    ``bool` `f = 0;`   `    ``// push root node in the queue 'q'` `    ``q.push(root);`   `    ``while` `(f == 0) {`   `        ``// count number of nodes in the` `        ``// current level` `        ``int` `nc = q.size();`   `        ``// traverse the current level nodes` `        ``while` `(nc--) {`   `            ``// get front element from 'q'` `            ``Node* top = q.front();` `            ``q.pop();`   `            ``// if it is a leaf node` `            ``if` `(!top->left && !top->right) {`   `                ``// accumulate data to 'sum'` `                ``sum += top->data;`   `                ``// set flag 'f' to 1, to signify ` `                ``// minimum level for leaf nodes ` `                ``// has been encountered` `                ``f = 1;` `            ``}` `            ``else` `{`   `                ``// if top's left and right child ` `                ``// exists, then push them to 'q'` `                ``if` `(top->left)` `                    ``q.push(top->left);` `                ``if` `(top->right)` `                    ``q.push(top->right);` `            ``}` `        ``}` `    ``}`   `    ``// required sum` `    ``return` `sum;` `}`   `// Driver program to test above` `int` `main()` `{` `    ``// binary tree creation` `    ``Node* root = getNode(1);` `    ``root->left = getNode(2);` `    ``root->right = getNode(3);` `    ``root->left->left = getNode(4);` `    ``root->left->right = getNode(5);` `    ``root->right->left = getNode(6);` `    ``root->right->right = getNode(7);` `    ``root->left->right->left = getNode(8);` `    ``root->right->left->right = getNode(9);`   `    ``cout << ``"Sum = "` `         ``<< sumOfLeafNodesAtMinLevel(root);`   `    ``return` `0;` `}`

## Java

 `// Java implementation to find the sum of` `// leaf nodes at minimum level` `import` `java.util.*;`   `class` `GFG ` `{`   `// structure of a node of binary tree` `static` `class` `Node ` `{` `    ``int` `data;` `    ``Node left, right;` `};`   `// function to get a new node` `static` `Node getNode(``int` `data)` `{` `    ``// allocate space` `    ``Node newNode = ``new` `Node();`   `    ``// put in the data` `    ``newNode.data = data;` `    ``newNode.left = newNode.right = ``null``;` `    ``return` `newNode;` `}`   `// function to find the sum of` `// leaf nodes at minimum level` `static` `int` `sumOfLeafNodesAtMinLevel(Node root)` `{` `    ``// if tree is empty` `    ``if` `(root == ``null``)` `        ``return` `0``;`   `    ``// if there is only one node` `    ``if` `(root.left == ``null` `&&` `        ``root.right == ``null``)` `        ``return` `root.data;`   `    ``// queue used for level order traversal` `    ``Queue q = ``new` `LinkedList<>();` `    ``int` `sum = ``0``; ` `    ``boolean` `f = ``false``;`   `    ``// push root node in the queue 'q'` `    ``q.add(root);`   `    ``while` `(f == ``false``)` `    ``{`   `        ``// count number of nodes in the` `        ``// current level` `        ``int` `nc = q.size();`   `        ``// traverse the current level nodes` `        ``while` `(nc-- >``0``)` `        ``{`   `            ``// get front element from 'q'` `            ``Node top = q.peek();` `            ``q.remove();`   `            ``// if it is a leaf node` `            ``if` `(top.left == ``null` `&& ` `                ``top.right == ``null``) ` `            ``{`   `                ``// accumulate data to 'sum'` `                ``sum += top.data;`   `                ``// set flag 'f' to 1, to signify ` `                ``// minimum level for leaf nodes ` `                ``// has been encountered` `                ``f = ``true``;` `            ``}` `            ``else` `            ``{`   `                ``// if top's left and right child ` `                ``// exists, then push them to 'q'` `                ``if` `(top.left != ``null``)` `                    ``q.add(top.left);` `                ``if` `(top.right != ``null``)` `                    ``q.add(top.right);` `            ``}` `        ``}` `    ``}`   `    ``// required sum` `    ``return` `sum;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// binary tree creation` `    ``Node root = getNode(``1``);` `    ``root.left = getNode(``2``);` `    ``root.right = getNode(``3``);` `    ``root.left.left = getNode(``4``);` `    ``root.left.right = getNode(``5``);` `    ``root.right.left = getNode(``6``);` `    ``root.right.right = getNode(``7``);` `    ``root.left.right.left = getNode(``8``);` `    ``root.right.left.right = getNode(``9``);`   `    ``System.out.println(``"Sum = "` `+ ` `           ``sumOfLeafNodesAtMinLevel(root));` `    ``}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation to find the sum` `# of leaf node at minimum level` `from` `collections ``import` `deque`   `# Structure of a node in binary tree` `class` `Node:` `    `  `    ``def` `__init__(``self``, data):` `        `  `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# function to find the sum of leaf nodes` `# at minimum level` `def` `sumOfLeafNodesAtLeafLevel(root):`   `    ``# if tree is empty` `    ``if` `not` `root:` `        ``return` `0`   `    ``# if there is only root node` `    ``if` `not` `root.left ``and` `not` `root.right:` `        ``return` `root.data`   `    ``# Queue used for level order traversal` `    ``Queue ``=` `deque()` `    ``sum` `=` `f ``=` `0`   `    ``# push root node in the queue` `    ``Queue.append(root)`   `    ``while` `not` `f:` `        `  `        ``# count no. of nodes present at current level` `        ``nc ``=` `len``(Queue)`   `        ``# traverse current level nodes` `        ``while` `nc:` `            ``top ``=` `Queue.popleft()`   `            ``# if node is leaf node` `            ``if` `not` `top.left ``and` `not` `top.right:` `                ``sum` `+``=` `top.data`   `                ``# set flag = 1 to signify that` `                ``# we have encountered the minimum level` `                ``f ``=` `1` `            ``else``:`   `                ``# if top's left or right child exist` `                ``# push them to Queue` `                ``if` `top.left:` `                    ``Queue.append(top.left)` `                ``if` `top.right:` `                    ``Queue.append(top.right)` `            ``nc ``-``=` `1`   `    ``# return the sum` `    ``return` `sum`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# binary tree creation` `    ``root ``=` `Node(``1``)` `    ``root.left ``=` `Node(``2``)` `    ``root.right ``=` `Node(``3``)` `    ``root.left.left ``=` `Node(``4``)` `    ``root.left.right ``=` `Node(``5``)` `    ``root.right.left ``=` `Node(``6``)` `    ``root.right.right ``=` `Node(``7``)` `    ``root.left.right.left ``=` `Node(``8``)` `    ``root.right.left.right ``=` `Node(``9``)`   `    ``print``(``"Sum = "``, sumOfLeafNodesAtLeafLevel(root))`   `# This code is contributed by` `# Mayank Chaudhary (chaudhary_19)`

## C#

 `// C# implementation to find the sum of` `// leaf nodes at minimum level` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{`   `// structure of a node of binary tree` `class` `Node ` `{` `    ``public` `int` `data;` `    ``public` `Node left, right;` `};`   `// function to get a new node` `static` `Node getNode(``int` `data)` `{` `    ``// allocate space` `    ``Node newNode = ``new` `Node();`   `    ``// put in the data` `    ``newNode.data = data;` `    ``newNode.left = newNode.right = ``null``;` `    ``return` `newNode;` `}`   `// function to find the sum of` `// leaf nodes at minimum level` `static` `int` `sumOfLeafNodesAtMinLevel(Node root)` `{` `    ``// if tree is empty` `    ``if` `(root == ``null``)` `        ``return` `0;`   `    ``// if there is only one node` `    ``if` `(root.left == ``null` `&&` `        ``root.right == ``null``)` `        ``return` `root.data;`   `    ``// queue used for level order traversal` `    ``Queue q = ``new` `Queue();` `    ``int` `sum = 0; ` `    ``bool` `f = ``false``;`   `    ``// push root node in the queue 'q'` `    ``q.Enqueue(root);`   `    ``while` `(f == ``false``)` `    ``{`   `        ``// count number of nodes in the` `        ``// current level` `        ``int` `nc = q.Count;`   `        ``// traverse the current level nodes` `        ``while` `(nc-- >0)` `        ``{`   `            ``// get front element from 'q'` `            ``Node top = q.Peek();` `            ``q.Dequeue();`   `            ``// if it is a leaf node` `            ``if` `(top.left == ``null` `&& ` `                ``top.right == ``null``) ` `            ``{`   `                ``// accumulate data to 'sum'` `                ``sum += top.data;`   `                ``// set flag 'f' to 1, to signify ` `                ``// minimum level for leaf nodes ` `                ``// has been encountered` `                ``f = ``true``;` `            ``}` `            ``else` `            ``{`   `                ``// if top's left and right child ` `                ``// exists, then push them to 'q'` `                ``if` `(top.left != ``null``)` `                    ``q.Enqueue(top.left);` `                ``if` `(top.right != ``null``)` `                    ``q.Enqueue(top.right);` `            ``}` `        ``}` `    ``}`   `    ``// required sum` `    ``return` `sum;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// binary tree creation` `    ``Node root = getNode(1);` `    ``root.left = getNode(2);` `    ``root.right = getNode(3);` `    ``root.left.left = getNode(4);` `    ``root.left.right = getNode(5);` `    ``root.right.left = getNode(6);` `    ``root.right.right = getNode(7);` `    ``root.left.right.left = getNode(8);` `    ``root.right.left.right = getNode(9);`   `    ``Console.WriteLine(``"Sum = "` `+ ` `            ``sumOfLeafNodesAtMinLevel(root));` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

`Sum = 11`

Time Complexity: O(n).
Auxiliary Space: O(n).

Another Method using Recursion

Here we will use the concept of traversal of a binary tree. In the function call, will take the root node and level variable, for tracking the levels of every node, also we will be using a hash-map, whose key is our value of level and the other as a vector for storing the node’s data for that particular node . For every recursive call, we will increase the level variable, and if the current node is a leaf node then we will push into a map with the key as level and node’s data into a vector.  Once we get our map, will simply sum the vector of very first element of our map;

Let’s see the code once, and your every confusion will be gone.

## C++

 `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `};`   `// function to get a new node` `Node* getNode(``int` `data)` `{` `    ``// allocate space` `    ``Node* newNode = (Node*)``malloc``(``sizeof``(Node));`   `    ``// put in the data` `    ``newNode->data = data;` `    ``newNode->left = newNode->right = NULL;` `    ``return` `newNode;` `}`     `    ``map <``int``, vector <``int``>> mp;` `    ``void` `solve(Node* root, ``int` `level) {` `        ``if``(root == NULL)    ` `            ``return``;` `        ``if``(root->left == NULL && root->right == NULL)` `            ``mp[level].push_back(root->data);` `        ``solve(root->left, level+1);` `        ``solve(root->right, level+1);` `    ``}` `    ``int` `minLeafSum(Node *root)` `    ``{` `        ``solve(root, 0);` `        ``int` `sum = 0;` `        ``for``(``auto` `i:mp) {` `            ``for``(``auto` `j:i.second) {` `                ``sum += j;` `            ``}` `            ``return` `sum;` `        ``}` `    ``}`   `int` `main() {` `    ``// binary tree creation` `    ``Node* root = getNode(1);` `    ``root->left = getNode(2);` `    ``root->right = getNode(3);` `    ``root->left->left = getNode(4);` `    ``root->left->right = getNode(5);` `    ``root->right->left = getNode(6);` `    ``root->right->right = getNode(7);` `      ``cout << ``"Sum = "``<< minLeafSum(root);` `    ``return` `0;` `}`

Output

`Sum = 22`

My Personal Notes arrow_drop_up
Recommended Articles
Page :