Sum of nodes on the longest path from root to leaf node
Given a binary tree containing n nodes. The problem is to find the sum of all nodes on the longest path from root to leaf node. If two or more paths compete for the longest path, then the path having maximum sum of nodes is being considered.
Examples:
Input : Binary tree:
4
/ \
2 5
/ \ / \
7 1 2 3
/
6
Output : 13
4
/ \
2 5
/ \ / \
7 1 2 3
/
6
The highlighted nodes (4, 2, 1, 6) above are
part of the longest root to leaf path having
sum = (4 + 2 + 1 + 6) = 13
Approach: Recursively find the length and sum of nodes of each root to leaf path and accordingly update the maximum sum.
Algorithm:
sumOfLongRootToLeafPath(root, sum, len, maxLen, maxSum)
if root == NULL
if maxLen < len
maxLen = len
maxSum = sum
else if maxLen == len && maxSum is less than sum
maxSum = sum
return
sumOfLongRootToLeafPath(root-left, sum + root-data,
len + 1, maxLen, maxSum)
sumOfLongRootToLeafPath(root-right, sum + root-data,
len + 1, maxLen, maxSum)
sumOfLongRootToLeafPathUtil(root)
if (root == NULL)
return 0
Declare maxSum = Minimum Integer
Declare maxLen = 0
sumOfLongRootToLeafPath(root, 0, 0, maxLen, maxSum)
return maxSum
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;
}
void sumOfLongRootToLeafPath(Node* root, int sum,
int len, int & maxLen, int & maxSum)
{
if (!root) {
if (maxLen < len) {
maxLen = len;
maxSum = sum;
} else if (maxLen == len && maxSum < sum)
maxSum = sum;
return ;
}
sumOfLongRootToLeafPath(root->left, sum + root->data,
len + 1, maxLen, maxSum);
sumOfLongRootToLeafPath(root->right, sum + root->data,
len + 1, maxLen, maxSum);
}
int sumOfLongRootToLeafPathUtil(Node* root)
{
if (!root)
return 0;
int maxSum = INT_MIN, maxLen = 0;
sumOfLongRootToLeafPath(root, 0, 0, maxLen, maxSum);
return maxSum;
}
int main()
{
Node* root = getNode(4);
root->left = getNode(2);
root->right = getNode(5);
root->left->left = getNode(7);
root->left->right = getNode(1);
root->right->left = getNode(2);
root->right->right = getNode(3);
root->left->right->left = getNode(6);
cout << "Sum = "
<< sumOfLongRootToLeafPathUtil(root);
return 0;
}
|
Java
public class GFG
{
static class Node {
int data;
Node left, right;
Node( int data){
this .data = data;
left = null ;
right = null ;
}
}
static int maxLen;
static int maxSum;
static void sumOfLongRootToLeafPath(Node root, int sum,
int len)
{
if (root == null ) {
if (maxLen < len) {
maxLen = len;
maxSum = sum;
} else if (maxLen == len && maxSum < sum)
maxSum = sum;
return ;
}
sumOfLongRootToLeafPath(root.left, sum + root.data,
len + 1 );
sumOfLongRootToLeafPath(root.right, sum + root.data,
len + 1 );
}
static int sumOfLongRootToLeafPathUtil(Node root)
{
if (root == null )
return 0 ;
maxSum = Integer.MIN_VALUE;
maxLen = 0 ;
sumOfLongRootToLeafPath(root, 0 , 0 );
return maxSum;
}
public static void main(String args[])
{
Node root = new Node( 4 );
root.left = new Node( 2 );
root.right = new Node( 5 );
root.left.left = new Node( 7 );
root.left.right = new Node( 1 );
root.right.left = new Node( 2 );
root.right.right = new Node( 3 );
root.left.right.left = new Node( 6 );
System.out.println( "Sum = "
+ sumOfLongRootToLeafPathUtil(root));
}
}
|
Python3
class getNode:
def __init__( self , data):
self .data = data
self .left = self .right = None
def SumOfLongRootToLeafPath(root, Sum , Len ,
maxLen, maxSum):
if ( not root):
if (maxLen[ 0 ] < Len ):
maxLen[ 0 ] = Len
maxSum[ 0 ] = Sum
else if (maxLen[ 0 ] = = Len and
maxSum[ 0 ] < Sum ):
maxSum[ 0 ] = Sum
return
SumOfLongRootToLeafPath(root.left, Sum + root.data,
Len + 1 , maxLen, maxSum)
SumOfLongRootToLeafPath(root.right, Sum + root.data,
Len + 1 , maxLen, maxSum)
def SumOfLongRootToLeafPathUtil(root):
if ( not root):
return 0
maxSum = [ - 999999999999 ]
maxLen = [ 0 ]
SumOfLongRootToLeafPath(root, 0 , 0 ,
maxLen, maxSum)
return maxSum[ 0 ]
if __name__ = = '__main__' :
root = getNode( 4 )
root.left = getNode( 2 )
root.right = getNode( 5 )
root.left.left = getNode( 7 )
root.left.right = getNode( 1 )
root.right.left = getNode( 2 )
root.right.right = getNode( 3 )
root.left.right.left = getNode( 6 )
print ( "Sum = " , SumOfLongRootToLeafPathUtil(root))
|
C#
using System;
public class GFG
{
public class Node
{
public int data;
public Node left, right;
public Node( int data)
{
this .data = data;
left = null ;
right = null ;
}
}
public static int maxLen;
public static int maxSum;
public static void sumOfLongRootToLeafPath(Node root, int sum, int len)
{
if (root == null )
{
if (maxLen < len)
{
maxLen = len;
maxSum = sum;
}
else if (maxLen == len && maxSum < sum)
{
maxSum = sum;
}
return ;
}
sumOfLongRootToLeafPath(root.left, sum + root.data, len + 1);
sumOfLongRootToLeafPath(root.right, sum + root.data, len + 1);
}
public static int sumOfLongRootToLeafPathUtil(Node root)
{
if (root == null )
{
return 0;
}
maxSum = int .MinValue;
maxLen = 0;
sumOfLongRootToLeafPath(root, 0, 0);
return maxSum;
}
public static void Main( string [] args)
{
Node root = new Node(4);
root.left = new Node(2);
root.right = new Node(5);
root.left.left = new Node(7);
root.left.right = new Node(1);
root.right.left = new Node(2);
root.right.right = new Node(3);
root.left.right.left = new Node(6);
Console.WriteLine( "Sum = " + sumOfLongRootToLeafPathUtil(root));
}
}
|
Javascript
<script>
class Node {
constructor(val) {
this .data = val;
this .left = null ;
this .right = null ;
}
}
var maxLen;
var maxSum;
function sumOfLongRootToLeafPath(root , sum,
len)
{
if (root == null )
{
if (maxLen < len) {
maxLen = len;
maxSum = sum;
} else if (maxLen == len && maxSum < sum)
maxSum = sum;
return ;
}
sumOfLongRootToLeafPath(root.left, sum + root.data,
len + 1);
sumOfLongRootToLeafPath(root.right, sum + root.data,
len + 1);
}
function sumOfLongRootToLeafPathUtil(root)
{
if (root == null )
return 0;
maxSum = Number.MIN_VALUE;
maxLen = 0;
sumOfLongRootToLeafPath(root, 0, 0);
return maxSum;
}
var root = new Node(4);
root.left = new Node(2);
root.right = new Node(5);
root.left.left = new Node(7);
root.left.right = new Node(1);
root.right.left = new Node(2);
root.right.right = new Node(3);
root.left.right.left = new Node(6);
document.write( "Sum = "
+ sumOfLongRootToLeafPathUtil(root));
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(h) where h is the height of the binary tree.
Another Approach: Using level order traversal
- Create a structure containing the current Node, level and sum in the path.
- Push the root element with level 0 and sum as the root’s data.
- Pop the front element and update the maximum level sum and maximum level if needed.
- Push the left and right nodes if exists.
- Do the same for all the nodes in tree.
Below is the implementation of the above approach.
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
Node* left;
Node* right;
int data;
Node( int element){
data = element;
this ->left = nullptr;
this ->right = nullptr;
}
};
int longestPathLeaf(Node* root){
struct Element{
Node* data;
int level;
int sum;
};
int maxSumLevel = root->data,maxLevel = 0;
list<Element> que;
Element e;
e.data = root;
e.level = 0;
e.sum = root->data;
que.push_back(e);
while (!que.empty()){
Element front = que.front();
Node* curr = front.data;
que.pop_front();
if (front.level > maxLevel){
maxSumLevel = front.sum;
maxLevel = front.level;
}
else if (front.level == maxLevel && front.sum > maxSumLevel)
maxSumLevel = front.sum;
if (curr->left){
e.data = curr->left;
e.sum = e.data->data;
e.sum += front.sum;
e.level = front.level+1;
que.push_back(e);
}
if (curr->right){
e.data = curr->right;
e.sum = e.data->data;
e.sum += front.sum;
e.level = front.level+1;
que.push_back(e);
}
}
return maxSumLevel;
}
int main() {
Node* root = new Node(4);
root->left = new Node(2);
root->right = new Node(5);
root->left->left = new Node(7);
root->left->right = new Node(1);
root->right->left = new Node(2);
root->right->right = new Node(3);
root->left->right->left = new Node(6);
cout << longestPathLeaf(root) << "\n" ;
return 0;
}
|
Java
import java.util.*;
class Main {
static class Node {
Node left;
Node right;
int data;
Node( int element)
{
data = element;
this .left = null ;
this .right = null ;
}
}
static class Element {
Node data;
int level;
int sum;
}
public static int longestPathLeaf(Node root)
{
int maxSumLevel = root.data;
int maxLevel = 0 ;
Queue<Element> que = new LinkedList<>();
Element e = new Element();
e.data = root;
e.level = 0 ;
e.sum = root.data;
que.add(e);
while (!que.isEmpty()) {
Element front = que.poll();
Node curr = front.data;
if (front.level > maxLevel) {
maxSumLevel = front.sum;
maxLevel = front.level;
}
else if (front.level == maxLevel
&& front.sum > maxSumLevel) {
maxSumLevel = front.sum;
}
if (curr.left != null ) {
e = new Element();
e.data = curr.left;
e.sum = e.data.data;
e.sum += front.sum;
e.level = front.level + 1 ;
que.add(e);
}
if (curr.right != null ) {
e = new Element();
e.data = curr.right;
e.sum = e.data.data;
e.sum += front.sum;
e.level = front.level + 1 ;
que.add(e);
}
}
return maxSumLevel;
}
public static void main(String[] args)
{
Node root = new Node( 4 );
root.left = new Node( 2 );
root.right = new Node( 5 );
root.left.left = new Node( 7 );
root.left.right = new Node( 1 );
root.right.left = new Node( 2 );
root.right.right = new Node( 3 );
root.left.right.left = new Node( 6 );
System.out.println(longestPathLeaf(root));
}
}
|
Python3
class Node:
def __init__( self , element):
self .data = element
self .left = None
self .right = None
class Element:
def __init__( self , data, level, sum ):
self .data = data
self .level = level
self . sum = sum
class Solution:
def longestPathLeaf( self , root):
maxSumLevel = root.data
maxLevel = 0
que = []
e = Element(root, 0 , root.data)
que.append(e)
while len (que) ! = 0 :
front = que[ 0 ]
curr = front.data
del que[ 0 ]
if front.level > maxLevel:
maxSumLevel = front. sum
maxLevel = front.level
elif front.level = = maxLevel and front. sum > maxSumLevel:
maxSumLevel = front. sum
if curr.left ! = None :
e = Element(curr.left, front.level + 1 , curr.left.data + front. sum )
que.append(e)
if curr.right ! = None :
e = Element(curr.right, front.level + 1 ,
curr.right.data + front. sum )
que.append(e)
return maxSumLevel
if __name__ = = '__main__' :
s = Solution()
root = Node( 4 )
root.left = Node( 2 )
root.right = Node( 5 )
root.left.left = Node( 7 )
root.left.right = Node( 1 )
root.right.left = Node( 2 )
root.right.right = Node( 3 )
root.left.right.left = Node( 6 )
print (s.longestPathLeaf(root))
|
C#
using System;
using System.Collections;
class Node {
public Node left;
public Node right;
public int data;
public Node( int element)
{
data = element;
this .left = null ;
this .right = null ;
}
}
class Element {
public Node data;
public int level;
public int sum;
}
class GFG {
public static int longestPathLeaf(Node root)
{
int maxSumLevel = root.data;
int maxLevel = 0;
Queue que = new Queue();
Element e = new Element();
e.data = root;
e.level = 0;
e.sum = root.data;
que.Enqueue(e);
while (que.Count != 0) {
dynamic front = que.Dequeue();
Node curr = front.data;
if (front.level > maxLevel) {
maxSumLevel = front.sum;
maxLevel = front.level;
}
else if (front.level == maxLevel
&& front.sum > maxSumLevel) {
maxSumLevel = front.sum;
}
if (curr.left != null ) {
e = new Element();
e.data = curr.left;
e.sum = e.data.data;
e.sum += front.sum;
e.level = front.level + 1;
que.Enqueue(e);
}
if (curr.right != null ) {
e = new Element();
e.data = curr.right;
e.sum = e.data.data;
e.sum += front.sum;
e.level = front.level + 1;
que.Enqueue(e);
}
}
return maxSumLevel;
}
public static void Main( string [] args)
{
Node root = new Node(4);
root.left = new Node(2);
root.right = new Node(5);
root.left.left = new Node(7);
root.left.right = new Node(1);
root.right.left = new Node(2);
root.right.right = new Node(3);
root.left.right.left = new Node(6);
Console.WriteLine(longestPathLeaf(root));
}
}
|
Javascript
class Node {
constructor(element) {
this .data = element;
this .left = null ;
this .right = null ;
}
}
class Element {
constructor(data, level, sum) {
this .data = data;
this .level = level;
this .sum = sum;
}
}
class Solution {
longestPathLeaf(root) {
let maxSumLevel = root.data;
let maxLevel = 0;
let que = [];
let e = new Element(root, 0, root.data);
que.push(e);
while (que.length !== 0) {
let front = que[0];
let curr = front.data;
que.shift();
if (front.level > maxLevel) {
maxSumLevel = front.sum;
maxLevel = front.level;
}
else if (front.level === maxLevel && front.sum > maxSumLevel) {
maxSumLevel = front.sum;
}
if (curr.left !== null ) {
e = new Element(curr.left, front.level + 1, curr.left.data + front.sum);
que.push(e);
}
if (curr.right !== null ) {
e = new Element(curr.right, front.level + 1, curr.right.data + front.sum);
que.push(e);
}
}
return maxSumLevel;
}
}
const s = new Solution();
const root = new Node(4);
root.left = new Node(2);
root.right = new Node(5);
root.left.left = new Node(7);
root.left.right = new Node(1);
root.right.left = new Node(2);
root.right.right = new Node(3);
root.left.right.left = new Node(6);
console.log(s.longestPathLeaf(root));
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Last Updated :
15 Jun, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...