Sum of nodes at maximum depth of a Binary Tree | Iterative Approach

• Difficulty Level : Easy
• Last Updated : 26 Aug, 2022

Given a root node to a tree, find the sum of all the leaf nodes which are at maximum depth from the 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, the sum of these nodes = 22```

Approach: There exists a recursive approach to this problem. This can also be solved using level order traversal and map. The idea is to do a traversal using a queue and keep track of the current level. A map has been used to store the sum of nodes at the current level. Once all nodes are visited and the traversal is done, the last element of the map will contain the sum at the maximum depth of the tree.

Below is the implementation of the above approach:

C++

 `// C++ program to calculate the sum of``// nodes at the maximum depth of a binary tree``#include ``using` `namespace` `std;` `struct` `node {``    ``int` `data;``    ``node *left, *right;``} * temp;` `node* newNode(``int` `data)``{``    ``temp = ``new` `node;``    ``temp->data = data;``    ``temp->left = temp->right = NULL;` `    ``return` `temp;``}` `// Function to return the sum``int` `SumAtMaxLevel(node* root)``{``    ``// Map to store level wise sum.``    ``map<``int``, ``int``> mp;` `    ``// Queue for performing Level Order Traversal.``    ``// First entry is the node and``    ``// second entry is the level of this node.``    ``queue > q;` `    ``// Root has level 0.``    ``q.push({ root, 0 });` `    ``while` `(!q.empty()) {` `        ``// Get the node from front of Queue.``        ``pair temp = q.front();``        ``q.pop();` `        ``// Get the depth of current node.``        ``int` `depth = temp.second;` `        ``// Add the value of this node in map.``        ``mp[depth] += (temp.first)->data;` `        ``// Push children of this node,``        ``// with increasing the depth.``        ``if` `(temp.first->left)``            ``q.push({ temp.first->left, depth + 1 });` `        ``if` `(temp.first->right)``            ``q.push({ temp.first->right, depth + 1 });``    ``}` `    ``map<``int``, ``int``>::iterator it;` `    ``// Get the max depth from map.``    ``it = mp.end();` `    ``// last element``    ``it--;` `    ``// return the max Depth sum.``    ``return` `it->second;``}` `// Driver Code``int` `main()``{``    ``node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);``    ``root->right->left = newNode(6);``    ``root->right->right = newNode(7);` `    ``cout << SumAtMaxLevel(root) << endl;``    ``return` `0;``}`

Java

 `// Java program to calculate``// the sum of nodes at the``// maximum depth of a binary tree``import` `java.util.HashMap;``import` `java.util.LinkedList;``import` `java.util.Queue;` `class` `GFG{``    ` `static` `class` `Node``{``  ``int` `data;``  ``Node left, right;``  ``public` `Node(``int` `data)``  ``{``    ``this``.data = data;``    ``this``.left = ``this``.right =``                ``null``;``  ``}``}` `static` `class` `Pair``{``  ``Node node;``  ``int` `data;``  ``public` `Pair(Node node,``              ``int` `data)``  ``{``    ``this``.node = node;``    ``this``.data = data;``  ``}``}` `// Function to return the sum``static` `int` `SumAtMaxLevel(Node root)``{``  ``// Map to store level wise sum.``  ``HashMap mp = ``new` `HashMap<>();` `  ``// Queue for performing Level``  ``// Order Traversal. First entry``  ``// is the node and second entry``  ``// is the level of this node.``  ``Queue q = ``new` `LinkedList<>();` `  ``// Root has level 0.``  ``q.add(``new` `Pair(root, ``0``));` `  ``while` `(!q.isEmpty())``  ``{``    ``// Get the node from``    ``// front of Queue.``    ``Pair temp = q.poll();` `    ``// Get the depth of``    ``// current node.``    ``int` `depth = temp.data;` `    ``// Add the value of this``    ``// node in map.``    ``if` `(!mp.containsKey(depth))``      ``mp.put(depth, ``0``);``    ``mp.put(depth, mp.get(depth) +``           ``temp.node.data);` `    ``// Push children of this node,``    ``// with increasing the depth.``    ``if` `(temp.node.left != ``null``)``      ``q.add(``new` `Pair(temp.node.left,``                     ``depth + ``1``));` `    ``if` `(temp.node.right != ``null``)``      ``q.add(``new` `Pair(temp.node.right,``                     ``depth + ``1``));``  ``}` `  ``Object[] values = mp.values().toArray();``  ``return` `(``int``) values[values.length - ``1``];``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``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``);` `  ``System.out.println(SumAtMaxLevel(root));``}     ``}` `// This code is contributed by sanjeev2552`

Python3

 `# Python3 program to calculate the``# sum of nodes at the maximum depth``# of a binary tree` `# Helper function that allocates a``# new node with the given data and``# None left and right pointers.                                    ``class` `newNode:` `    ``# Constructor to create a new node``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to return the sum``def` `SumAtMaxLevel(root):` `    ``# Map to store level wise sum.``    ``mp ``=` `{}` `    ``# Queue for performing Level Order``    ``# Traversal. First entry is the node``    ``# and second entry is the level of``    ``# this node.``    ``q ``=` `[]` `    ``# Root has level 0.``    ``q.append([root, ``0``])` `    ``while` `(``len``(q)):` `        ``# Get the node from front``        ``# of Queue.``        ``temp ``=` `q[``0``]``        ``q.pop(``0``)` `        ``# Get the depth of current node.``        ``depth ``=` `temp[``1``]` `        ``# Add the value of this node in map.``        ``if` `depth ``not` `in` `mp:``            ``mp[depth] ``=` `0``        ``mp[depth] ``+``=` `(temp[``0``]).data` `        ``# append children of this node,``        ``# with increasing the depth.``        ``if` `(temp[``0``].left) :``            ``q.append([temp[``0``].left,``                        ``depth ``+` `1``])` `        ``if` `(temp[``0``].right) :``            ``q.append([temp[``0``].right,``                         ``depth ``+` `1``])` `    ``# return the max Depth sum.``    ``return` `list``(mp.values())[``-``1``]``        ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Let us construct the Tree``    ``# shown in the above figure``    ``root ``=` `newNode(``1``)``    ``root.left ``=` `newNode(``2``)``    ``root.right ``=` `newNode(``3``)``    ``root.left.left ``=` `newNode(``4``)``    ``root.left.right ``=` `newNode(``5``)``    ``root.right.left ``=` `newNode(``6``)``    ``root.right.right ``=` `newNode(``7``)``    ``print``(SumAtMaxLevel(root))` `# This code is contributed by``# Shubham Singh(SHUBHAMSINGH10)`

C#

 `// C# program to calculate``// the sum of nodes at the``// maximum depth of a binary tree``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;``using` `System.Linq;`` ` `class` `GFG{``     ` `class` `Node``{``  ``public` `int` `data;``public` `Node left, right;``  ``public` `Node(``int` `data)``  ``{``    ``this``.data = data;``    ``this``.left = ``this``.right =``                ``null``;``  ``}``}`` ` `class` `Pair``{``  ``public` `Node node;``  ``public` `int` `data;``  ``public` `Pair(Node node,``              ``int` `data)``  ``{``    ``this``.node = node;``    ``this``.data = data;``  ``}``}`` ` `// Function to return the sum``static` `int` `SumAtMaxLevel(Node root)``{``  ``// Map to store level wise sum.``  ``Dictionary<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>();`` ` `  ``// Queue for performing Level``  ``// Order Traversal. First entry``  ``// is the node and second entry``  ``// is the level of this node.``  ``Queue q = ``new` `Queue();`` ` `  ``// Root has level 0.``  ``q.Enqueue(``new` `Pair(root, 0));`` ` `  ``while` `(q.Count != 0)``  ``{``    ``// Get the node from``    ``// front of Queue.``    ``Pair temp = (Pair)q.Dequeue();`` ` `    ``// Get the depth of``    ``// current node.``    ``int` `depth = temp.data;`` ` `    ``// Add the value of this``    ``// node in map.``    ``if` `(!mp.ContainsKey(depth))``      ``mp[depth]= 0;``      ` `    ``mp[depth] = mp[depth]+temp.node.data;`` ` `    ``// Push children of this node,``    ``// with increasing the depth.``    ``if` `(temp.node.left != ``null``)``      ``q.Enqueue(``new` `Pair(temp.node.left,``                     ``depth + 1));`` ` `    ``if` `(temp.node.right != ``null``)``      ``q.Enqueue(``new` `Pair(temp.node.right,``                     ``depth + 1));``  ``}`` ` `  ``return` `mp.Values.Last();``}`` ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``  ``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);`` ` `  ``Console.WriteLine(SumAtMaxLevel(root));``}     ``}` `// This code is contributed by rutvik_56`

Javascript

 ``

Output

```22
```

Complexity Analysis:

• Time Complexity : O(N)
• Auxiliary Space: O(N)

My Personal Notes arrow_drop_up