Sum of nodes at maximum depth of a Binary Tree

• Difficulty Level : Easy
• Last Updated : 11 Nov, 2021

Given a root node to a tree, find the sum of all the leaf nodes which are at maximum depth from root node.

Example:

1
/   \
2     3
/ \   / \
4   5 6   7

Input : root(of above tree)
Output : 22

Explanation:
Nodes at maximum depth are: 4, 5, 6, 7.
So, sum of these nodes = 22

While traversing the nodes compare the level of the node with max_level (Maximum level till the current node). If the current level exceeds the maximum level, update the max_level as the current level. If the max level and current level are the same, add the root data to the current sum. if the level is less than max_level, do nothing.

C++

 // Code to find the sum of the nodes// which are present at the maximum depth.#include  using namespace std; int sum = 0, max_level = INT_MIN; struct Node{    int d;    Node *l;    Node *r;}; // Function to return a new nodeNode* createNode(int d){    Node *node;    node = new Node;    node->d = d;    node->l = NULL;    node->r = NULL;    return node;} // Function to find the sum of the node// which are present at the maximum depth.// While traversing the nodes compare the level// of the node with max_level// (Maximum level till the current node).// If the current level exceeds the maximum level,// update the max_level as current level.// If the max level and current level are same,// add the root data to current sum.void sumOfNodesAtMaxDepth(Node *ro,int level){    if(ro == NULL)    return;    if(level > max_level)    {        sum = ro -> d;        max_level = level;    }    else if(level == max_level)    {        sum = sum + ro -> d;    }    sumOfNodesAtMaxDepth(ro -> l, level + 1);    sumOfNodesAtMaxDepth(ro -> r, level + 1);} // Driver Codeint main(){    Node *root;    root = createNode(1);    root->l = createNode(2);    root->r = createNode(3);    root->l->l = createNode(4);    root->l->r = createNode(5);    root->r->l = createNode(6);    root->r->r = createNode(7);    sumOfNodesAtMaxDepth(root, 0);    cout << sum;    return 0;}

Java

 // Java code to find the sum of the nodes// which are present at the maximum depth.class GFG{ static int sum = 0, max_level = Integer.MIN_VALUE; static class Node{    int d;    Node l;    Node r;}; // Function to return a new nodestatic Node createNode(int d){    Node node;    node = new Node();    node.d = d;    node.l = null;    node.r = null;    return node;} // Function to find the sum of the node// which are present at the maximum depth.// While traversing the nodes compare the level// of the node with max_level// (Maximum level till the current node).// If the current level exceeds the maximum level,// update the max_level as current level.// If the max level and current level are same,// add the root data to current sum.static void sumOfNodesAtMaxDepth(Node ro,int level){    if(ro == null)    return;    if(level > max_level)    {        sum = ro . d;        max_level = level;    }    else if(level == max_level)    {        sum = sum + ro . d;    }    sumOfNodesAtMaxDepth(ro . l, level + 1);    sumOfNodesAtMaxDepth(ro . r, level + 1);} // Driver Codepublic static void main(String[] args){    Node root;    root = createNode(1);    root.l = createNode(2);    root.r = createNode(3);    root.l.l = createNode(4);    root.l.r = createNode(5);    root.r.l = createNode(6);    root.r.r = createNode(7);    sumOfNodesAtMaxDepth(root, 0);    System.out.println(sum);}} /* This code is contributed by PrinciRaj1992 */

Python3

 # Python3 code to find the sum of the nodes# which are present at the maximum depth.sum = max_level = [-(2**32)] # Binary tree nodeclass createNode:         def __init__(self, data):        self.d = data        self.l = None        self.r = None # Function to find the sum of the node# which are present at the maximum depth.# While traversing the nodes compare the level# of the node with max_level# (Maximum level till the current node).# If the current level exceeds the maximum level,# update the max_level as current level.# If the max level and current level are same,# add the root data to current sum.def sumOfNodesAtMaxDepth(ro, level):         if(ro == None):        return         if(level > max_level):        sum = ro . d        max_level = level         elif(level == max_level):        sum = sum + ro . d         sumOfNodesAtMaxDepth(ro . l, level + 1)    sumOfNodesAtMaxDepth(ro . r, level + 1)     # Driver Coderoot = createNode(1)root.l = createNode(2)root.r = createNode(3)root.l.l = createNode(4)root.l.r = createNode(5)root.r.l = createNode(6)root.r.r = createNode(7)sumOfNodesAtMaxDepth(root, 0)print(sum) # This code is contributed by SHUBHAMSINGH10

C#

 // C# code to find the sum of the nodes// which are present at the maximum depth.using System; class GFG{ static int sum = 0, max_level = int.MinValue; public class Node{    public int d;    public Node l;    public Node r;}; // Function to return a new nodestatic Node createNode(int d){    Node node;    node = new Node();    node.d = d;    node.l = null;    node.r = null;    return node;} // Function to find the sum of the node// which are present at the maximum depth.// While traversing the nodes compare the level// of the node with max_level// (Maximum level till the current node).// If the current level exceeds the maximum level,// update the max_level as current level.// If the max level and current level are same,// add the root data to current sum.static void sumOfNodesAtMaxDepth(Node ro,int level){    if(ro == null)    return;    if(level > max_level)    {        sum = ro . d;        max_level = level;    }    else if(level == max_level)    {        sum = sum + ro . d;    }    sumOfNodesAtMaxDepth(ro . l, level + 1);    sumOfNodesAtMaxDepth(ro . r, level + 1);} // Driver Codepublic static void Main(String[] args){    Node root;    root = createNode(1);    root.l = createNode(2);    root.r = createNode(3);    root.l.l = createNode(4);    root.l.r = createNode(5);    root.r.l = createNode(6);    root.r.r = createNode(7);    sumOfNodesAtMaxDepth(root, 0);    Console.WriteLine(sum);}} // This code is contributed by Princi Singh

Javascript



Output :

22

This article is contributed by Ashwin Loganathan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Approach: Calculate the max depth of the given tree. Now, start traversing the tree similarly as traversed during maximum depth calculation. But, this time with one more argument (i.e. maxdepth), and traverse recursively with decreasing depth by 1 for each left or right call. Wherever max == 1, means the node at max depth is reached. So add its data value to sum. Finally, return sum.

Below is the implementation for the above approach:

C++

 // C++ code for sum of nodes// at maximum depth#include using namespace std; struct Node{    int data;    Node* left, *right;     // Constructor    Node(int data)    {        this->data = data;        this->left = NULL;        this->right = NULL;    }};     // function to find the sum of nodes at    // maximum depth arguments are node and    // max, where max is to match the depth    // of node at every call to node, if    // max will be equal to 1, means    // we are at deepest node.    int sumMaxLevelRec(Node* node, int max)    {        // base case        if (node == NULL)            return 0;             // max == 1 to track the node        // at deepest level        if (max == 1)            return node->data;         // recursive call to left and right nodes        return sumMaxLevelRec(node->left, max - 1) +            sumMaxLevelRec(node->right, max - 1);    }         // maxDepth function to find the    // max depth of the tree    int maxDepth(Node* node)    {        // base case        if (node == NULL)            return 0;             // either leftDepth of rightDepth is        // greater add 1 to include height        // of node at which call is        return 1 + max(maxDepth(node->left),                        maxDepth(node->right));        }     int sumMaxLevel(Node* root)    {         // call to function to calculate        // max depth        int MaxDepth = maxDepth(root);                 return sumMaxLevelRec(root, MaxDepth);    }     // Driver code    int main()    {         /*     1            / \            2 3            / \ / \            4 5 6 7     */         // Constructing tree        Node* root = new Node(1);        root->left = new Node(2);        root->right = new Node(3);        root->left->left = new Node(4);        root->left->right = new Node(5);        root->right->left = new Node(6);        root->right->right = new Node(7);         // call to calculate required sum        cout<<(sumMaxLevel(root))<

Java

 // Java code for sum of nodes// at maximum depthimport java.util.*; class Node {    int data;    Node left, right;     // Constructor    public Node(int data)    {        this.data = data;        this.left = null;        this.right = null;    }} class GfG {     // function to find the sum of nodes at    // maximum depth arguments are node and    // max, where max is to match the depth    // of node at every call to node, if    // max will be equal to 1, means    // we are at deepest node.    public static int sumMaxLevelRec(Node node,                     int max)    {        // base case        if (node == null)            return 0;             // max == 1 to track the node        // at deepest level        if (max == 1)            return node.data;            // recursive call to left and right nodes        return sumMaxLevelRec(node.left, max - 1) +               sumMaxLevelRec(node.right, max - 1);    }     public static int sumMaxLevel(Node root) {         // call to function to calculate        // max depth        int MaxDepth = maxDepth(root);                 return sumMaxLevelRec(root, MaxDepth);    }     // maxDepth function to find the    // max depth of the tree    public static int maxDepth(Node node)    {        // base case        if (node == null)            return 0;             // either leftDepth of rightDepth is        // greater add 1 to include height        // of node at which call is        return 1 + Math.max(maxDepth(node.left),                           maxDepth(node.right));        }     // Driver code    public static void main(String[] args)    {         /*      1              / \              2   3            / \ / \            4 5 6 7     */         // Constructing tree        Node root = new Node(1);        root.left = new Node(2);        root.right = new Node(3);        root.left.left = new Node(4);        root.left.right = new Node(5);        root.right.left = new Node(6);        root.right.right = new Node(7);          // call to calculate required sum        System.out.println(sumMaxLevel(root));    }}

Python3

 # Python3 code for sum of nodes at maximum depthclass Node:     def __init__(self, data):        self.data = data        self.left = None        self.right = None # Function to find the sum of nodes at maximum depth# arguments are node and max, where Max is to match# the depth of node at every call to node, if Max# will be equal to 1, means we are at deepest node.def sumMaxLevelRec(node, Max):     # base case    if node == None:        return 0        # Max == 1 to track the node at deepest level    if Max == 1:        return node.data         # recursive call to left and right nodes    return (sumMaxLevelRec(node.left, Max - 1) +            sumMaxLevelRec(node.right, Max - 1)) def sumMaxLevel(root):     # call to function to calculate max depth    MaxDepth = maxDepth(root)    return sumMaxLevelRec(root, MaxDepth) # maxDepth function to find# the max depth of the treedef maxDepth(node):     # base case    if node == None:        return 0        # Either leftDepth of rightDepth is    # greater add 1 to include height    # of node at which call is    return 1 + max(maxDepth(node.left),                    maxDepth(node.right)) # Driver codeif __name__ == "__main__":     # Constructing tree    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)     # call to calculate required sum    print(sumMaxLevel(root)) # This code is contributed by Rituraj Jain

C#

 using System; // C# code for sum of nodes// at maximum depth public class Node{    public int data;    public Node left, right;     // Constructor    public Node(int data)    {        this.data = data;        this.left = null;        this.right = null;    }} public class GfG{     // function to find the sum of nodes at    // maximum depth arguments are node and    // max, where max is to match the depth    // of node at every call to node, if    // max will be equal to 1, means    // we are at deepest node.    public static int sumMaxLevelRec(Node node, int max)    {        // base case        if (node == null)        {            return 0;        }         // max == 1 to track the node        // at deepest level        if (max == 1)        {            return node.data;        }         // recursive call to left and right nodes        return sumMaxLevelRec(node.left, max - 1)                + sumMaxLevelRec(node.right, max - 1);    }     public static int sumMaxLevel(Node root)    {         // call to function to calculate        // max depth        int MaxDepth = maxDepth(root);         return sumMaxLevelRec(root, MaxDepth);    }     // maxDepth function to find the    // max depth of the tree    public static int maxDepth(Node node)    {        // base case        if (node == null)        {            return 0;        }         // either leftDepth of rightDepth is        // greater add 1 to include height        // of node at which call is        return 1 + Math.Max(maxDepth(node.left),                            maxDepth(node.right));    }     // Driver code    public static void Main(string[] args)    {         /*     1            / \            2 3            / \ / \            4 5 6 7     */         // Constructing tree        Node root = new Node(1);        root.left = new Node(2);        root.right = new Node(3);        root.left.left = new Node(4);        root.left.right = new Node(5);        root.right.left = new Node(6);        root.right.right = new Node(7);          // call to calculate required sum        Console.WriteLine(sumMaxLevel(root));    }} // This code is contributed by Shrikant13

Javascript



Output :

22

Time Complexity: O(N), where N is the number of nodes in the tree.

Method 3:- Using a Queue

Approach: In this approach, the idea is to traverse the tree in level order and for each level calculate the sum of all the nodes in that level. For each level, we push all the nodes of the tree into the queue and calculate the sum of the nodes. So, when we reach the end leaves in the tree, the sum is the total sum of all the leaves in the binary tree.

Below is the implementation of the above approach:

C++

 // C++ code for the above approach#include using namespace std; struct TreeNode{    int val;    TreeNode *left;    TreeNode *right;}; // Function to return a new nodeTreeNode *createNode(int d){    TreeNode *node;    node = new TreeNode();    node->val = d;    node->left = NULL;    node->right = NULL;    return node;} // Iterative function to find the sum of the deepest// nodes.int deepestLeavesSum(TreeNode *root){       // if the root is NULL then return 0    if (root == NULL)    {        return 0;    }       // Initialize an empty queue.    queue qu;       // push the root of the tree into the queue    qu.push(root);       // initialize sum of current level to 0    int sumOfCurrLevel = 0;       // loop until the queue is not empty    while (!qu.empty())    {        int size = qu.size();        sumOfCurrLevel = 0;        while (size-- > 0)        {            TreeNode *head = qu.front();            qu.pop();            sumOfCurrLevel += head->val;            // if the left child of the head is not NULL            if (head->left != NULL)            {                //push the child into the queue                qu.push(head->left);            }                       // if the right child is not NULL            if (head->right != NULL)            {                               // push the child into the queue                qu.push(head->right);            }        }    }    return sumOfCurrLevel;} // Driver codeint main(){     TreeNode *root;    root = createNode(1);    root->left = createNode(2);    root->right = createNode(3);    root->left->left = createNode(4);    root->left->right = createNode(5);    root->right->left = createNode(6);    root->right->right = createNode(7);    cout << (deepestLeavesSum(root));    return 0;} // This code is contributed by Potta Lokesh

Java

 // Java code to print the sum of leaves present at maximum// depth of a binary treeimport java.util.*; class GFG {     static class TreeNode {        int val;        TreeNode left;        TreeNode right;    };     // Function to return a new node    static TreeNode createNode(int d)    {        TreeNode node;        node = new TreeNode();        node.val = d;        node.left = null;        node.right = null;        return node;    }    // Iterative function to find the sum of the deepest    // nodes.    public static int deepestLeavesSum(TreeNode root)    {          // if the root is null then return 0        if (root== null) {            return 0;        }          // Initialize an empty queue.        Queue qu= new LinkedList<>();        // push the root of the tree into the queue        qu.offer(root);        // initialize sum of current level to 0        int sumOfCurrLevel= 0;          // loop until the queue is not empty        while (!qu.isEmpty()) {            int size = qu.size();            sumOfCurrLevel = 0;            while (size-- > 0) {                TreeNode head = qu.poll();                sumOfCurrLevel += head.val;                // if the left child of the head is not null                if (head.left!= null) {                    //push the child into the queue                    qu.offer(head.left);                }                // if the right child is not null                if (head.right!= null) {                   // push the child into the queue                    qu.offer(head.right);                }            }        }        return sumOfCurrLevel;    }    public static void main(String[] args)    {         TreeNode root;        root = createNode(1);        root.left = createNode(2);        root.right = createNode(3);        root.left.left = createNode(4);        root.left.right = createNode(5);        root.right.left = createNode(6);        root.right.right = createNode(7);        System.out.println(deepestLeavesSum(root));    }}// this code is contributed by Rohan Raj

Javascript


Output
22

Time complexity: O(N) where N is the number of nodes in the tree.

My Personal Notes arrow_drop_up