Maximum sum of leaf nodes among all levels of the given binary tree
Last Updated :
27 Jan, 2023
Given a Binary Tree having positive and negative nodes, the task is to find the maximum sum of leaf nodes among all level of the given binary tree.
Examples:
Input:
4
/ \
2 -5
/ \
-1 3
Output: 2
Sum of all leaves at 0th level is 0.
Sum of all leaves at 1st level is -5.
Sum of all leaves at 2nd level is 2.
Hence maximum sum is 2.
Input:
1
/ \
2 3
/ \ \
4 5 8
/ \
6 7
Output: 13
Approach: The idea to solve the above problem is to do level order traversal of tree. While doing traversal, process nodes of different level separately. For every level being processed, compute the sum of leaf nodes in the level and keep track of the maximum sum.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node *left, *right;
};
int maxLeafNodesSum(struct Node* root)
{
if (root == NULL)
return 0;
int result = 0;
queue<Node*> q;
q.push(root);
while (!q.empty()) {
int count = q.size();
int sum = 0;
while (count--) {
Node* temp = q.front();
q.pop();
if (temp->left == NULL && temp->right == NULL)
sum = sum + temp->data;
if (temp->left != NULL)
q.push(temp->left);
if (temp->right != NULL)
q.push(temp->right);
}
result = max(sum, result);
}
return result;
}
struct Node* newNode(int data)
{
struct Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return (node);
}
int main()
{
struct Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->right = newNode(8);
root->right->right->left = newNode(6);
root->right->right->right = newNode(7);
cout << maxLeafNodesSum(root) << endl;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
};
static int maxLeafNodesSum(Node root)
{
if (root == null)
return 0;
int result = 0;
Queue<Node> q = new LinkedList<>();
q.add(root);
while (!q.isEmpty())
{
int count = q.size();
int sum = 0;
while (count-- > 0)
{
Node temp = q.peek();
q.remove();
if (temp.left == null &&
temp.right == null)
sum = sum + temp.data;
if (temp.left != null)
q.add(temp.left);
if (temp.right != null)
q.add(temp.right);
}
result = Math.max(sum, result);
}
return result;
}
static Node newNode(int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null;
return (node);
}
public static void main(String[] args)
{
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.right = newNode(8);
root.right.right.left = newNode(6);
root.right.right.right = newNode(7);
System.out.println(maxLeafNodesSum(root));
}
}
|
Python3
class newNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def maxLeafNodesSum(root):
if (root == None):
return 0
result = 0
q = []
q.append(root)
while(len(q)):
count = len(q)
sum = 0
while (count):
temp = q[0]
q.pop(0)
if (temp.left == None and
temp.right == None):
sum = sum + temp.data
if (temp.left != None):
q.append(temp.left)
if (temp.right != None):
q.append(temp.right)
count -= 1
result = max(sum, result)
return result
root = newNode(1)
root.left = newNode(2)
root.right = newNode(3)
root.left.left = newNode(4)
root.left.right = newNode(5)
root.right.right = newNode(8)
root.right.right.left = newNode(6)
root.right.right.right = newNode(7)
print(maxLeafNodesSum(root))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
class Node
{
public int data;
public Node left, right;
};
static int maxLeafNodesSum(Node root)
{
if (root == null)
return 0;
int result = 0;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
while (q.Count != 0)
{
int count = q.Count;
int sum = 0;
while (count-- > 0)
{
Node temp = q.Peek();
q.Dequeue();
if (temp.left == null &&
temp.right == null)
sum = sum + temp.data;
if (temp.left != null)
q.Enqueue(temp.left);
if (temp.right != null)
q.Enqueue(temp.right);
}
result = Math.Max(sum, result);
}
return result;
}
static Node newNode(int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null;
return (node);
}
public static void Main(String[] args)
{
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.right = newNode(8);
root.right.right.left = newNode(6);
root.right.right.right = newNode(7);
Console.WriteLine(maxLeafNodesSum(root));
}
}
|
Javascript
<script>
class Node
{
constructor(data) {
this.left = null;
this.right = null;
this.data = data;
}
}
function maxLeafNodesSum(root)
{
if (root == null)
return 0;
let result = 0;
let q = [];
q.push(root);
while (q.length > 0)
{
let count = q.length;
let sum = 0;
while (count-- > 0)
{
let temp = q[0];
q.shift();
if (temp.left == null &&
temp.right == null)
sum = sum + temp.data;
if (temp.left != null)
q.push(temp.left);
if (temp.right != null)
q.push(temp.right);
}
result = Math.max(sum, result);
}
return result;
}
function newNode(data)
{
let node = new Node(data);
return (node);
}
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.right = newNode(8);
root.right.right.left = newNode(6);
root.right.right.right = newNode(7);
document.write(maxLeafNodesSum(root));
</script>
|
Time complexity: O(N) where N is the number of node in the given binary tree.
Auxiliary Space: O(N) due to queue data structure.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...