Find the sum of leafs at maximum level
Last Updated :
30 May, 2022
Given a binary tree containing n nodes. The task is to find the sum of all the leaf nodes present at maximum level.
Examples:
Input:
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
Output: 17
Leaf nodes 8 and 9 are at maximum level.
Their sum = (8 + 9) = 17.
Input:
5
/ \
8 13
/
4
Output: 4
Approach: Perform iterative level order traversal using queue and find the sum of the nodes at each level and if there are no children for every node at the current level mark this level as the maximum level. Sum of all the leaf nodes at maximum level will be the required answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node *left, *right;
};
Node* getNode( int data)
{
Node* newNode = (Node*) malloc ( sizeof (Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
int sumOfLeafNodesAtMaxLevel(Node* root)
{
if (!root)
return 0;
if (!root->left && !root->right)
return root->data;
queue<Node*> q;
int leafSum = 0;
bool f = 0;
q.push(root);
while ( true ) {
int nc = q.size();
if (nc == 0)
return leafSum;
leafSum = 0;
while (nc--) {
Node* top = q.front();
q.pop();
if (!top->left && !top->right) {
leafSum += top->data;
}
else {
if (top->left)
q.push(top->left);
if (top->right)
q.push(top->right);
}
}
}
}
int main()
{
Node* root = getNode(1);
root->left = getNode(2);
root->right = getNode(3);
root->left->left = getNode(4);
root->left->right = getNode(5);
root->right->left = getNode(6);
root->right->right = getNode(7);
root->left->right->left = getNode(8);
root->right->left->right = getNode(9);
cout << sumOfLeafNodesAtMaxLevel(root);
return 0;
}
|
Java
import java.util.*;
class GFG {
static class Node {
int data;
Node left, right;
};
static Node getNode( int data)
{
Node newNode = new Node();
newNode.data = data;
newNode.left = newNode.right = null ;
return newNode;
}
static int sumOfLeafNodesAtMaxLevel(Node root)
{
if (root == null )
return 0 ;
if (root.left == null && root.right == null )
return root.data;
Queue<Node> q = new LinkedList<>();
int leafSum = 0 ;
boolean f = false ;
q.add(root);
while ( true ) {
int nc = q.size();
if (nc == 0 )
return leafSum;
leafSum = 0 ;
while (nc-- > 0 ) {
Node top = q.peek();
q.remove();
if (top.left == null && top.right == null ) {
leafSum += top.data;
}
else {
if (top.left != null )
q.add(top.left);
if (top.right != null )
q.add(top.right);
}
}
}
}
public static void main(String args[])
{
Node root = getNode( 1 );
root.left = getNode( 2 );
root.right = getNode( 3 );
root.left.left = getNode( 4 );
root.left.right = getNode( 5 );
root.right.left = getNode( 6 );
root.right.right = getNode( 7 );
root.left.right.left = getNode( 8 );
root.right.left.right = getNode( 9 );
System.out.print(sumOfLeafNodesAtMaxLevel(root));
}
}
|
Python3
class Node:
def __init__( self ):
self .data = 0
self .left = None
self .right = None
def getNode(data):
newNode = Node()
newNode.data = data
newNode.left = newNode.right = None
return newNode
def sumOfLeafNodesAtMaxLevel(root):
if (root = = None ):
return 0
if (root.left = = None and root.right = = None ):
return root.data
q = []
leafSum = 0
q.append(root)
while ( True ):
nc = len (q)
if (nc = = 0 ):
return leafSum
leafSum = 0
while (nc > 0 ):
top = q[ 0 ]
q.pop( 0 )
if (top.left = = None and top.right = = None ):
leafSum + = top.data
else :
if (top.left ! = None ):
q.append(top.left)
if (top.right ! = None ):
q.append(top.right)
nc - = 1
root = getNode( 1 )
root.left = getNode( 2 )
root.right = getNode( 3 )
root.left.left = getNode( 4 )
root.left.right = getNode( 5 )
root.right.left = getNode( 6 )
root.right.right = getNode( 7 )
root.left.right.left = getNode( 8 )
root.right.left.right = getNode( 9 )
print (sumOfLeafNodesAtMaxLevel(root))
|
C#
using System;
using System.Collections.Generic;
class GFG {
public class Node {
public int data;
public Node left, right;
};
static Node getNode( int data)
{
Node newNode = new Node();
newNode.data = data;
newNode.left = newNode.right = null ;
return newNode;
}
static int sumOfLeafNodesAtMaxLevel(Node root)
{
if (root == null )
return 0;
if (root.left == null && root.right == null )
return root.data;
Queue<Node> q = new Queue<Node>();
int leafSum = 0;
q.Enqueue(root);
while ( true ) {
int nc = q.Count;
if (nc == 0)
return leafSum;
leafSum = 0;
while (nc-- > 0) {
Node top = q.Peek();
q.Dequeue();
if (top.left == null && top.right == null ) {
leafSum += top.data;
}
else {
if (top.left != null )
q.Enqueue(top.left);
if (top.right != null )
q.Enqueue(top.right);
}
}
}
}
public static void Main(String[] args)
{
Node root = getNode(1);
root.left = getNode(2);
root.right = getNode(3);
root.left.left = getNode(4);
root.left.right = getNode(5);
root.right.left = getNode(6);
root.right.right = getNode(7);
root.left.right.left = getNode(8);
root.right.left.right = getNode(9);
Console.Write(sumOfLeafNodesAtMaxLevel(root));
}
}
|
Javascript
<script>
class Node {
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
};
function getNode(data)
{
var newNode = new Node();
newNode.data = data;
newNode.left = newNode.right = null ;
return newNode;
}
function sumOfLeafNodesAtMaxLevel(root)
{
if (root == null )
return 0;
if (root.left == null && root.right == null )
return root.data;
var q = [];
var leafSum = 0;
q.push(root);
while ( true ) {
var nc = q.length;
if (nc == 0)
return leafSum;
leafSum = 0;
while (nc-- > 0) {
var top = q[0];
q.shift();
if (top.left == null && top.right == null ) {
leafSum += top.data;
}
else {
if (top.left != null )
q.push(top.left);
if (top.right != null )
q.push(top.right);
}
}
}
}
var root = getNode(1);
root.left = getNode(2);
root.right = getNode(3);
root.left.left = getNode(4);
root.left.right = getNode(5);
root.right.left = getNode(6);
root.right.right = getNode(7);
root.left.right.left = getNode(8);
root.right.left.right = getNode(9);
document.write(sumOfLeafNodesAtMaxLevel(root));
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(n)
Share your thoughts in the comments
Please Login to comment...