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






                        filter_none









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







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 Program to find sum of nodes at maximum 


# Depth of the Binary Tree 


  


# Variables to store sum and 


# maximum level 


sum = [0] 


max_level = [-(2**32)] 


  


# Binary tree node  


class createNode:  


      


    def __init__(self, data):  


        self.data = data  


        self.left = None


        self.right = None


  


# Function to find the sum of the node which 


# are present at the maximum depth 


def sumOfNodesAtMaxDepth(root, level): 


    if (root == None): 


        return


      


    # If the current level exceeds the 


    # maximum level, update the max_level 


    # as current level. 


    if (level > max_level[0]): 


        sum[0] = root.data 


        max_level[0] = level 


          


    # If the max level and current level 


    #are same, add the root data to 


    # current sum. 


    elif (level == max_level[0]): 


        sum[0] = sum[0] + root.data 


          


    # Traverse the left and right subtrees 


    sumOfNodesAtMaxDepth(root.left, level + 1) 


    sumOfNodesAtMaxDepth(root.right, level + 1) 


      


# Driver Code 


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) 


  


print(sum[0]) 


  


# This code is contributed by SHUBHAMSINGH10 



















                        chevron_right







                        filter_none









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 


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



















                        chevron_right







                        filter_none











Output:


22







Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.





    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
Ashwin Loganathan
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.