Maximum sum of non-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 non-leaf nodes among all levels of the given binary tree.
Examples:
Input:
4
/ \
2 -5
/ \
-1 3
Output: 4
Sum of all non-leaf nodes at 0th level is 4.
Sum of all non-leaf nodes at 1st level is 2.
Sum of all non-leaf nodes at 2nd level is 0.
Hence maximum sum is 4
Input:
1
/ \
2 3
/ \ \
4 5 8
/ \
6 7
Output: 8
Approach: The idea to solve the above problem is to do the level order traversal of the tree. While doing traversal, process nodes of different levels separately. For every level being processed, compute the sum of non-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 maxNonLeafNodesSum( 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 << maxNonLeafNodesSum(root) << endl;
return 0;
}
|
Java
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 int maxNonLeafNodesSum(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.poll();
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 = max(sum, result);
}
return result;
}
static int max( int sum,
int result)
{
if (sum > result)
return sum;
return result;
}
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.right = new Node( 8 );
root.right.right.left = new Node( 6 );
root.right.right.right = new Node( 7 );
System.out.println(maxNonLeafNodesSum(root));
}
}
|
Python3
import queue
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def maxNonLeafNodesSum(root):
if root = = None :
return 0
result = 0
q = queue.Queue()
q.put(root)
while not q.empty():
count = q.qsize()
Sum = 0
while count:
temp = q.get()
if temp.left ! = None or temp.right ! = None :
Sum + = temp.data
if temp.left ! = None :
q.put(temp.left)
if temp.right ! = None :
q.put(temp.right)
count - = 1
result = max ( Sum , result)
return result
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.right = Node( 8 )
root.right.right.left = Node( 6 )
root.right.right.right = Node( 7 )
print (maxNonLeafNodesSum(root))
|
C#
using System;
using System.Collections;
class GFG{
class Node
{
public int data;
public Node left, right;
public Node( int data)
{
this .data = data;
this .left = this .right = null ;
}
};
static int maxNonLeafNodesSum(Node root)
{
if (root == null )
return 0;
int result = 0;
Queue q = new Queue();
q.Enqueue(root);
while (q.Count != 0)
{
int count = q.Count;
int sum = 0;
while (count-- > 0)
{
Node temp = (Node)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 = max(sum, result);
}
return result;
}
static int max( int sum,
int result)
{
if (sum > result)
return sum;
return result;
}
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.right = new Node(8);
root.right.right.left = new Node(6);
root.right.right.right = new Node(7);
Console.Write(maxNonLeafNodesSum(root));
}
}
|
Javascript
<script>
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
function maxNonLeafNodesSum(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 = max(sum, result);
}
return result;
}
function max(sum, result)
{
if (sum > result)
return sum;
return result;
}
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.right = new Node(8);
root.right.right.left = new Node(6);
root.right.right.right = new Node(7);
document.write(maxNonLeafNodesSum(root));
</script>
|
Time Complexity: O(N) where N is the number of nodes in the given tree.
Auxiliary Space: O(N) due to queue data structure.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...