Open In App
Related Articles

Sum of leaf nodes at minimum level

Improve Article
Improve
Save Article
Save
Like Article
Like

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.

Source: Microsoft IDC Interview Experience | Set 150.

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.

Implementation:

C++




// C++ implementation to find the sum of
// leaf nodes at minimum level
#include <bits/stdc++.h>
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<Node*> 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<Node> 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<Node> q = new Queue<Node>();
    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



<script>
 
    // JavaScript implementation to find the sum of
    // leaf nodes at minimum level
     
    class Node
    {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.data = data;
        }
    }
       
    // function to get a new node
    function getNode(data)
    {
        // allocate space
        let newNode = new Node(data);
        return newNode;
    }
 
    // function to find the sum of
    // leaf nodes at minimum level
    function sumOfLeafNodesAtMinLevel(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
        let q = [];
        let sum = 0;
        let f = false;
 
        // push root node in the queue 'q'
        q.push(root);
 
        while (f == false)
        {
 
            // count number of nodes in the
            // current level
            let nc = q.length;
 
            // traverse the current level nodes
            while (nc-- >0)
            {
 
                // get front element from 'q'
                let top = q[0];
                q.shift();
 
                // 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.push(top.left);
                    if (top.right != null)
                        q.push(top.right);
                }
            }
        }
 
        // required sum
        return sum;
    }
     
    // binary tree creation
    let 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);
   
    document.write("Sum = " +
           sumOfLeafNodesAtMinLevel(root));
 
</script>
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;
Implementation: Let’s see the code once, and your every confusion will be gone.
C++



#include <bits/stdc++.h>
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;
}
Java



// Java implementation ofabove approach
 
import java.util.TreeMap;
import java.util.Vector;
import java.util.Map.Entry;
 
class GFG {
 
    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;
    }
 
    static TreeMap<Integer, Vector <Integer>> mp = new TreeMap <Integer, Vector <Integer>>();
    static void solve(Node root, int level) {
        if(root == null)   
            return;
       
        if(root.left == null && root.right == null)
        {
            Vector<Integer> get =  mp.get(level);
            if(get == null)
            {
                get = new Vector<>();
                get.add(root.data);
            }
            else
                get.add(root.data);
            mp.put(level, get);
        }
       
        solve(root.left, level+1);
        solve(root.right, level+1);
    }
    static int minLeafSum(Node root)
    {
        solve(root, 0);
        int sum = 0;
        for (Entry<Integer, Vector<Integer>> i : mp.entrySet())
        {
            for(Integer j : i.getValue())
             {
              sum+=j;
            }
            return sum;
        }
        return 0;
    }
 
    // 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);
 
        System.out.println(
            "Sum = " + minLeafSum(root));
    }
}
 
// This code is contributed by Abhijeet Kumar(abhijeet19403)
Python3



# Python3 implementation of above approach
 
 
# Structure of a node in binary tree
class Node:
 
    def __init__(self, data):
 
        self.data = data
        self.left = None
        self.right = None
 
 
mp = dict()
def solve(root,level):
    if(root == None):
        return
    if root.left == None and root.right == None :
        try:
            mp[level].append(root.data)
        except:
            mp[level] = [root.data]
    solve(root.left, level+1)
    solve(root.right, level+1)
 
def minLeafSum(root):
 
    solve(root, 0)
    sum = 0
    for x, i in enumerate(sorted(mp)):
        for j in mp[i]:
            sum += j
        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)
 
    print("Sum = ", minLeafSum(root))
 
# This code is contributed by
# Abhijeet Kumar(abhijeet19403)
C#



// C# implementation of above approach
 
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;
    }
    static SortedDictionary<int, List<int> > mp
        = new SortedDictionary<int, List<int> >();
    static void solve(Node root, int level)
    {
        if (root == null)
            return;
 
        if (root.left == null && root.right == null) {
            List<int> get = new List<int>();
            if (mp.ContainsKey(level))
                get.AddRange(mp[level]);
            if (get == null) {
                get = new List<int>();
                get.Add(root.data);
            }
            else
                get.Add(root.data);
 
            mp[level] = get;
        }
 
        solve(root.left, level + 1);
        solve(root.right, level + 1);
    }
    static int minLeafSum(Node root)
    {
        solve(root, 0);
        int sum = 0;
        foreach(KeyValuePair<int, List<int> > i in mp)
        {
            foreach(int j in i.Value) sum += j;
            return sum;
        }
        return 0;
    }
 
    // 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);
 
        Console.WriteLine("Sum = " + minLeafSum(root));
    }
}
 
// This code is contributed by Abhijeet Kumar(abhijeet19403)
Javascript



class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
 
// function to get a new node
function getNode(data) {
    // allocate space
    let newNode = new Node(data);
    return newNode;
}
 
let mp = new Map();
function solve(root, level) {
    if (root == null)
        return;
    if (root.left == null && root.right == null)
        mp.has(level) ? mp.get(level).push(root.data) : mp.set(level, [root.data]);
    solve(root.left, level + 1);
    solve(root.right, level + 1);
}
 
function minLeafSum(root) {
    solve(root, 0);
    let sum = 0;
    for (const [key, value] of mp.entries()) {
        for (let j = 0; j < value.length; j++) {
            sum += value[j];
        }
        return sum;
    }
}
 
let 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);
console.log("Sum = " + minLeafSum(root));
 
// This code is contributed by lokeshpotta20.
Output
Sum = 22
Time Complexity: O(n) where n is the number of nodes in the tree.
Auxiliary Space: O(h) where h is the height of the binary tree.

Last Updated :
14 Mar, 2023
Like Article

Save Article

Similar Reads
Similar read thumbnail
Sum of Bitwise AND of the sum of all leaf and non-leaf nodes for each level of a Binary Tree
Similar read thumbnail
Difference between odd level and even level leaf sum in given Binary Tree
Similar read thumbnail
Sum of leaf nodes at each horizontal level in a binary tree
Similar read thumbnail
Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree
Similar read thumbnail
Print Leaf Nodes at a given Level
Similar read thumbnail
Calculate sum of all nodes present in a level for each level of a Tree
Similar read thumbnail
Construct a Tree whose sum of nodes of all the root to leaf path is not divisible by the count of nodes in that path
Similar read thumbnail
Difference between sums of odd level and even level nodes of a Binary Tree
Similar read thumbnail
Connect Nodes at same Level (Level Order Traversal)
Similar read thumbnail
Print the nodes corresponding to the level value for each level of a Binary Tree
Related Tutorials
Similar read thumbnail
Mathematical and Geometric Algorithms - Data Structure and Algorithm Tutorials
Similar read thumbnail
Learn Data Structures with Javascript | DSA Tutorial
Similar read thumbnail
Introduction to Max-Heap – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Set – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Map – Data Structure and Algorithm Tutorials
Previous
Pascal Matrix
Next

Find largest prime factor of a number
Article Contributed By :
A
ayushjauhari14
ayushjauhari14
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue 
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox