Sum of nodes at maximum depth of a Binary Tree

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

In the previous article we discussed a recursive solution which first finds the maximum level and then finds the sum of all nodes present at that level.

In this article we will see a recursive solution without finding the height or depth. The idea is that 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 otherwise if level is less than max_level, do nothing.

Below is the implementation of the above approach:

C++

// C++ Program to find sum of nodes at maximum 
// Depth of the Binary Tree 
  
#include <bits/stdc++.h> 
using namespace std; 
  
// Variables to store sum and 
// maximum level 
int sum = 0, max_level = INT_MIN; 
  
// Binary Tree Node 
struct Node { 
    int data; 
    Node* left; 
    Node* right; 
}; 
  
// Utility function to create and 
// return a new Binary Tree Node 
Node* createNode(int val) 
{ 
  
    Node* node = new Node; 
  
    node->data = val; 
    node->left = NULL; 
    node->right = NULL; 
  
    return node; 
} 
  
// Function to find the sum of the node which 
// are present at the maximum depth 
void sumOfNodesAtMaxDepth(Node* root, int level) 
{ 
    if (root == NULL) 
        return; 
  
    // If the current level exceeds the 
    // maximum level, update the max_level 
    // as current level. 
    if (level > max_level) { 
        sum = root->data; 
        max_level = level; 
    } 
  
    // If the max level and current level 
    // are same, add the root data to 
    // current sum. 
    else if (level == max_level) { 
        sum = sum + root->data; 
    } 
  
    // Traverse the left and right subtrees 
    sumOfNodesAtMaxDepth(root->left, level + 1); 
    sumOfNodesAtMaxDepth(root->right, level + 1); 
} 
  
// Driver Code 
int main() 
{ 
    Node* 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); 
  
    sumOfNodesAtMaxDepth(root, 0); 
  
    cout << sum; 
  
    return 0; 
} 

Java

// Java Program to find sum of nodes at maximum  
// Depth of the Binary Tree  
  
class GfG  
{ 
  
// Variables to store sum and  
// maximum level  
static int sum = 0, 
    max_level = Integer.MIN_VALUE;  
  
// Binary Tree Node  
static class Node  
{  
    int data;  
    Node left;  
    Node right;  
} 
  
// Utility function to create and  
// return a new Binary Tree Node  
static Node createNode(int val)  
{  
  
    Node node = new Node();  
    node.data = val;  
    node.left = null;  
    node.right = null;  
  
    return node;  
}  
  
// Function to find the sum of  
// the node which are present 
// at the maximum depth  
static void sumOfNodesAtMaxDepth(Node root,  
                                int level)  
{  
    if (root == null)  
        return;  
  
    // If the current level exceeds the  
    // maximum level, update the max_level  
    // as current level.  
    if (level > max_level)  
    {  
        sum = root.data;  
        max_level = level;  
    }  
  
    // If the max level and current level  
    // are same, add the root data to  
    // current sum.  
    else if (level == max_level)  
    {  
        sum = sum + root.data;  
    }  
  
    // Traverse the left and right subtrees  
    sumOfNodesAtMaxDepth(root.left, level + 1);  
    sumOfNodesAtMaxDepth(root.right, level + 1);  
}  
  
// Driver Code  
public static void main(String[] args)  
{  
    Node root = null;  
    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);  
  
    sumOfNodesAtMaxDepth(root, 0);  
    System.out.println(sum);  
} 
}  
  
// This code is contributed by  
// Prerna Saini. 

C#

// C#  Program to find sum of nodes at maximum  
// Depth of the Binary Tree 
using System; 
public class GfG  
{  
  
    // Variables to store sum and  
    // maximum level  
    static int sum = 0,  
        max_level = int.MinValue;  
  
    // Binary Tree Node  
    class Node  
    {  
        public int data;  
        public Node left;  
        public Node right;  
    }  
  
    // Utility function to create and  
    // return a new Binary Tree Node  
    static Node createNode(int val)  
    {  
  
        Node node = new Node();  
        node.data = val;  
        node.left = null;  
        node.right = null;  
  
        return node;  
    }  
  
    // Function to find the sum of  
    // the node which are present  
    // at the maximum depth  
    static void sumOfNodesAtMaxDepth(Node root,  
                                    int level)  
    {  
        if (root == null)  
            return;  
  
        // If the current level exceeds the  
        // maximum level, update the max_level  
        // as current level.  
        if (level > max_level)  
        {  
            sum = root.data;  
            max_level = level;  
        }  
  
        // If the max level and current level  
        // are same, add the root data to  
        // current sum.  
        else if (level == max_level)  
        {  
            sum = sum + root.data;  
        }  
  
        // Traverse the left and right subtrees  
        sumOfNodesAtMaxDepth(root.left, level + 1);  
        sumOfNodesAtMaxDepth(root.right, level + 1);  
    }  
  
    // Driver Code  
    public static void Main()  
    {  
        Node root = null;  
        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);  
  
        sumOfNodesAtMaxDepth(root, 0);  
        Console.WriteLine(sum);  
    }  
}  
  
/* This code is contributed PrinciRaj1992 */