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

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.if 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   #include using namespace std;    int sum = 0, max_level = INT_MIN;    struct Node {     int d;     Node *l;     Node *r; };    // Function to return a new node 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.  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 Code int 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 node  static 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 Code  public 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 = [0] max_level = [-(2**32)]    # Binary tree node  class 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[0]):         sum[0] = ro . d         max_level[0] = level            elif(level == max_level[0]):         sum[0] = sum[0] + ro . d            sumOfNodesAtMaxDepth(ro . l, level + 1)     sumOfNodesAtMaxDepth(ro . r, level + 1)         # Driver Code 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) print(sum[0])    # 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 node  static 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 Code  public 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

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 contribute.geeksforgeeks.org or mail your article to contribute@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 above approach:

## Java

 // Java code for sum of nodes // at maximum depth import 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 depth  class 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 tree  def 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 code  if __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

Output :

22

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

My Personal Notes arrow_drop_up

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.

Article Tags :
Practice Tags :

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.