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
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 the current level. If the max level and current level are the same, add the root data to the current sum. if the level is less than max_level, do nothing.
Implementation:
C++
Java
class GFG
{
static int sum = 0 , max_level = Integer.MIN_VALUE;
static class Node
{
int d;
Node l;
Node r;
};
static Node createNode( int d)
{
Node node;
node = new Node();
node.d = d;
node.l = null ;
node.r = null ;
return node;
}
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 );
}
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);
}
}
|
Python3
sum = [ 0 ]
max_level = [ - ( 2 * * 32 )]
class createNode:
def __init__( self , data):
self .d = data
self .l = None
self .r = None
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 )
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 ])
|
C#
Javascript
<script>
var sum = 0, max_level = -1000000000;
class Node
{
constructor()
{
this .d = 0;
this .l = null ;
this .r = null ;
}
};
function createNode(d)
{
var node;
node = new Node();
node.d = d;
node.l = null ;
node.r = null ;
return node;
}
function sumOfNodesAtMaxDepth(ro, 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);
}
var 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);
document.write(sum);
</script>
|
Complexity Analysis:
- Time Complexity: O(n), As we are visiting every node just once.
- Auxiliary Space: O(h), Here h is the height of the tree and the extra space is used in the recursion call stack.
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), 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 the sum. Finally, return the sum.
Below is the implementation for the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int data;
Node* left, *right;
Node( int data)
{
this ->data = data;
this ->left = NULL;
this ->right = NULL;
}
};
int sumMaxLevelRec(Node* node, int max)
{
if (node == NULL)
return 0;
if (max == 1)
return node->data;
return sumMaxLevelRec(node->left, max - 1) +
sumMaxLevelRec(node->right, max - 1);
}
int maxDepth(Node* node)
{
if (node == NULL)
return 0;
return 1 + max(maxDepth(node->left),
maxDepth(node->right));
}
int sumMaxLevel(Node* root)
{
int MaxDepth = maxDepth(root);
return sumMaxLevelRec(root, MaxDepth);
}
int main()
{
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);
cout<<(sumMaxLevel(root))<<endl;
}
|
Java
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def sumMaxLevelRec(node, Max ):
if node = = None :
return 0
if Max = = 1 :
return node.data
return (sumMaxLevelRec(node.left, Max - 1 ) +
sumMaxLevelRec(node.right, Max - 1 ))
def sumMaxLevel(root):
MaxDepth = maxDepth(root)
return sumMaxLevelRec(root, MaxDepth)
def maxDepth(node):
if node = = None :
return 0
return 1 + max (maxDepth(node.left),
maxDepth(node.right))
if __name__ = = "__main__" :
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 )
print (sumMaxLevel(root))
|
C#
Javascript
<script>
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
function sumMaxLevelRec(node, max)
{
if (node == null )
return 0;
if (max == 1)
return node.data;
return sumMaxLevelRec(node.left, max - 1) +
sumMaxLevelRec(node.right, max - 1);
}
function sumMaxLevel(root) {
let MaxDepth = maxDepth(root);
return sumMaxLevelRec(root, MaxDepth);
}
function maxDepth(node)
{
if (node == null )
return 0;
return 1 + Math.max(maxDepth(node.left),
maxDepth(node.right));
}
let 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);
document.write(sumMaxLevel(root));
</script>
|
Complexity Analysis:
- Time Complexity: O(N), where N is the number of nodes in the tree.
- Auxiliary Space: O(h), Here h is the height of the tree and the extra space is used in the recursion call stack.
Method 3: Using a Queue
Approach: In this approach, the idea is to traverse the tree in level order and for each level calculate the sum of all the nodes in that level. For each level, we push all the nodes of the tree into the queue and calculate the sum of the nodes. So, when we reach the end leaves in the tree, the sum is the total sum of all the leaves in the binary tree.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
int val;
TreeNode *left;
TreeNode *right;
};
TreeNode *createNode( int d)
{
TreeNode *node;
node = new TreeNode();
node->val = d;
node->left = NULL;
node->right = NULL;
return node;
}
int deepestLeavesSum(TreeNode *root)
{
if (root == NULL)
{
return 0;
}
queue<TreeNode *> qu;
qu.push(root);
int sumOfCurrLevel = 0;
while (!qu.empty())
{
int size = qu.size();
sumOfCurrLevel = 0;
while (size-- > 0)
{
TreeNode *head = qu.front();
qu.pop();
sumOfCurrLevel += head->val;
if (head->left != NULL)
{
qu.push(head->left);
}
if (head->right != NULL)
{
qu.push(head->right);
}
}
}
return sumOfCurrLevel;
}
int main()
{
TreeNode *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);
cout << (deepestLeavesSum(root));
return 0;
}
|
Java
import java.util.*;
class GFG {
static class TreeNode {
int val;
TreeNode left;
TreeNode right;
};
static TreeNode createNode( int d)
{
TreeNode node;
node = new TreeNode();
node.val = d;
node.left = null ;
node.right = null ;
return node;
}
public static int deepestLeavesSum(TreeNode root)
{
if (root== null ) {
return 0 ;
}
Queue<TreeNode> qu= new LinkedList<>();
qu.offer(root);
int sumOfCurrLevel= 0 ;
while (!qu.isEmpty()) {
int size = qu.size();
sumOfCurrLevel = 0 ;
while (size-- > 0 ) {
TreeNode head = qu.poll();
sumOfCurrLevel += head.val;
if (head.left!= null ) {
qu.offer(head.left);
}
if (head.right!= null ) {
qu.offer(head.right);
}
}
}
return sumOfCurrLevel;
}
public static void main(String[] args)
{
TreeNode 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 );
System.out.println(deepestLeavesSum(root));
}
}
|
Python3
class TreeNode:
def __init__( self ):
self .val = 0
self .left = None
self .right = None
def createNode(d):
node = TreeNode()
node.val = d
node.left = None
node.right = None
return node
def deepestLeavesSum(root):
if (root = = None ):
return 0
qu = []
qu.append(root)
sumOfCurrLevel = 0
while ( len (qu) ! = 0 ):
size = len (qu)
sumOfCurrLevel = 0
while (size):
head = qu[ 0 ]
qu = qu[ 1 :]
sumOfCurrLevel + = head.val
if (head.left! = None ):
qu.append(head.left)
if (head.right! = None ):
qu.append(head.right)
size - = 1
return sumOfCurrLevel
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 )
print (deepestLeavesSum(root))
|
C#
using System;
using System.Collections.Generic;
public class GFG {
public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
};
static TreeNode createNode( int d)
{
TreeNode node;
node = new TreeNode();
node.val = d;
node.left = null ;
node.right = null ;
return node;
}
public static int deepestLeavesSum(TreeNode root)
{
if (root == null )
{
return 0;
}
Queue<TreeNode> qu= new Queue<TreeNode>();
qu.Enqueue(root);
int sumOfCurrLevel= 0;
while (qu.Count != 0)
{
int size = qu.Count;
sumOfCurrLevel = 0;
while (size-- > 0)
{
TreeNode head = qu.Dequeue();
sumOfCurrLevel += head.val;
if (head.left!= null )
{
qu.Enqueue(head.left);
}
if (head.right!= null )
{
qu.Enqueue(head.right);
}
}
}
return sumOfCurrLevel;
}
public static void Main(String[] args)
{
TreeNode 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);
Console.WriteLine(deepestLeavesSum(root));
}
}
|
Javascript
<script>
class TreeNode
{
constructor()
{
this .val=0;
this .left= this .right= null ;
}
}
function createNode(d)
{
let node;
node = new TreeNode();
node.val = d;
node.left = null ;
node.right = null ;
return node;
}
function deepestLeavesSum(root)
{
if (root== null ) {
return 0;
}
let qu= [];
qu.push(root);
let sumOfCurrLevel= 0;
while (qu.length!=0) {
let size = qu.length;
sumOfCurrLevel = 0;
while (size-- > 0) {
let head = qu.shift();
sumOfCurrLevel += head.val;
if (head.left!= null ) {
qu.push(head.left);
}
if (head.right!= null ) {
qu.push(head.right);
}
}
}
return sumOfCurrLevel;
}
let 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);
document.write(deepestLeavesSum(root));
</script>
|
Complexity Analysis:
- Time Complexity: O(N) where N is the number of nodes in the tree.
- Auxiliary Space: O(b), Here b is the width of the tree and the extra space is used to store the elements of the current level in the queue.
Last Updated :
15 Sep, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...