Sum of nodes at maximum depth of a Binary Tree | Set 2

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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.

chevron_right


Output:

22


My Personal Notes arrow_drop_up