Find the maximum sum leaf to root path in a Binary Tree

Last Updated : 23 Jul, 2025

Given a Binary Tree, the task is to find the maximum sum path from a leaf to a root.

Example :

Input:

Binary-Tree-to-Binary-Search-Tree-Conversion-2

Output: 60
Explanantion: There are three leaf to root paths 20->30->10, 5->30->10 and 15->10. The sums of these three paths are 60, 45 and 25 respectively. The maximum of them is 60 and the path for maximum is 20->30->10.

Try It Yourself
redirect icon

Table of Content

[Naive Approach] By Checking Every Path - O(n * h) Time and O(n) Space

The idea is to check of all possible path from root to leaf recursively. So we check for every path that is from root to every leaf and take the sum which path has the maximum sum.

Follow the steps below to solve the problem:

  • Traverse the binary tree form root to every node and maintain a parent map which contains the parent of a node.
  • While traversing, if the current node don't has left or right child, then the node is a leaf node.
  • When we encounter a leaf node, call a separate function which calculates the sum from that leaf to root.
  • The function calculates the sum by using parent map by recursively calling the function with parent node until we reach root.
  • Maintain a variable which keeps and updates the maximum sum.

Below is the implementation of the above approach: 

C++ 
// CPP program to find maximum sum leaf to root
// path in Binary Tree by checking every path

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;
  	Node(int x) {
     	data = x;
      	left = right = nullptr;
    }
};
// Helper function to calculate the sum 
// from a leaf node to the root
int getSumOfPath(Node* root, unordered_map<Node*, Node*> &parent) {
  
    // If the current node has no parent, 
  	// return its data (it's the root)
    if (parent.find(root) == parent.end())
        return root->data;

    // Recursively sum the current node data
  	// with its parent's path sum
    return root->data + getSumOfPath(parent[root], parent);
}

// Function to calculate the maximum leaf-to-root path sum
void sumCal(Node* root, int &maxx, unordered_map<Node*, Node*> &parent) {
  
    // Check if the current node is a leaf node
    if (root->left == nullptr && root->right == nullptr) {
  
      	// Update the maximum sum if the 
      	// current path's sum is greater
        maxx = max(maxx, getSumOfPath(root, parent));
        return;
    }

    // If the left child exists, set the 
  	// current node as its parent and recurse
    if (root->left) {
        parent[root->left] = root;
        sumCal(root->left, maxx, parent);
    }

    // If the right child exists, set the 
  	// current node as its parent and recurse
    if (root->right) {
        parent[root->right] = root;
        sumCal(root->right, maxx, parent);
    }
}

// Function to return the maximum leaf-
// to-root path sum in the binary tree
int maxPathSum(Node* root) {
  
    // To store each node's parent for path calculation
    unordered_map<Node*, Node*> parent;

    // Variable to store the maximum sum
    int maxx = 0;

    // Recursively calculate the sum for all paths
    sumCal(root, maxx, parent);
    
    // Return the maximum path sum found
    return maxx;
}
int main() {
  
    // Constructing tree given
    //           10
    //         /    \
    //       -2      7
    //      /  \
    //     8   -4
    
  	Node *root = new Node(10);
    root->left = new Node(-2);
    root->right = new Node(7);
    root->left->left = new Node(8);
    root->left->right = new Node(-4);

    int sum = maxPathSum(root);
  	cout << sum << endl;
    return 0;
}
Java 
// Java program to find maximum sum leaf to root
// path in Binary Tree by checking every path

import java.util.HashMap;

class Node {
    int data;
    Node left, right;
    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Helper function to calculate the sum
    // from a leaf node to the root
    static int getSumOfPath(Node root, HashMap<Node, Node> parent) {
      
        // If the current node has no parent,
        // return its data (it's the root)
        if (!parent.containsKey(root))
            return root.data;

        // Recursively sum the current node data
        // with its parent's path sum
        return root.data + getSumOfPath(parent.get(root), parent);
    }

    // Function to calculate the maximum leaf-to-root path sum
    static void sumCal(Node root, int[] maxx,
                       HashMap<Node, Node> parent) {
      
        // Check if the current node is a leaf node
        if (root.left == null && root.right == null) {
          
            // Update the maximum sum if the
            // current path's sum is greater
            maxx[0] = Math.max(maxx[0], getSumOfPath(root, parent));
            return;
        }

        // If the left child exists, set the
        // current node as its parent and recurse
        if (root.left != null) {
            parent.put(root.left, root);
            sumCal(root.left, maxx, parent);
        }

        // If the right child exists, set the
        // current node as its parent and recurse
        if (root.right != null) {
            parent.put(root.right, root);
            sumCal(root.right, maxx, parent);
        }
    }

    // Function to return the maximum leaf-to-root 
  	// path sum in the binary tree
    static int maxPathSum(Node root) {
      
        // To store each node's parent for path calculation
        HashMap<Node, Node> parent = new HashMap<>();

        // Variable to store the maximum sum
        int[] maxx = {0};

        // Recursively calculate the sum for all paths
        sumCal(root, maxx, parent);

        // Return the maximum path sum found
        return maxx[0];
    }

    public static void main(String[] args) {
     
        // Constructing tree given
        //           10
        //         /    \
        //       -2      7
        //      /  \
        //     8   -4
        Node root = new Node(10);
        root.left = new Node(-2);
        root.right = new Node(7);
        root.left.left = new Node(8);
        root.left.right = new Node(-4);

        int sum = maxPathSum(root);
        System.out.println(sum);
    }
}
Python 
# Python program to find maximum sum leaf to root
# path in Binary Tree by checking every path

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Helper function to calculate the sum
# from a leaf node to the root
def get_sum_of_path(root, parent):
  
    # If the current node has no parent,
    # return its data (it's the root)
    if root not in parent:
        return root.data

    # Recursively sum the current node data
    # with its parent's path sum
    return root.data + get_sum_of_path(parent[root], parent)

# Function to calculate the maximum leaf-to-root path sum
def sum_cal(root, maxx, parent):
  
    # Check if the current node is a leaf node
    if root.left is None and root.right is None:
      
        # Update the maximum sum if the
        # current path's sum is greater
        maxx[0] = max(maxx[0], get_sum_of_path(root, parent))
        return

    # If the left child exists, set the
    # current node as its parent and recurse
    if root.left:
        parent[root.left] = root
        sum_cal(root.left, maxx, parent)

    # If the right child exists, set the
    # current node as its parent and recurse
    if root.right:
        parent[root.right] = root
        sum_cal(root.right, maxx, parent)

# Function to return the maximum leaf-to-root path 
# sum in the binary tree
def max_path_sum(root):
  
    # To store each node's parent for 
    # path calculation
    parent = {}

    # Variable to store the maximum sum
    maxx = [0]

    # Recursively calculate the sum for all paths
    sum_cal(root, maxx, parent)

    # Return the maximum path sum found
    return maxx[0]

if __name__ == "__main__":
  
    # Constructing tree given
    #           10
    #         /    \
    #       -2      7
    #      /  \
    #     8   -4
    root = Node(10)
    root.left = Node(-2)
    root.right = Node(7)
    root.left.left = Node(8)
    root.left.right = Node(-4)

    sum_result = max_path_sum(root)
    print(sum_result)
C# 
// C# program to find maximum sum leaf to root
// path in Binary Tree by checking every path

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Helper function to calculate the sum
    // from a leaf node to the root
    static int getSumOfPath(Node root, 
                            Dictionary<Node, Node> parent) {
      
        // If the current node has no parent,
        // return its data (it's the root)
        if (!parent.ContainsKey(root))
            return root.data;

        // Recursively sum the current node data
        // with its parent's path sum
        return root.data + getSumOfPath(parent[root], parent);
    }

    // Function to calculate the maximum leaf-to-root path sum
    static void sumCal(Node root, ref int maxx,
                       Dictionary<Node, Node> parent) {
      
        // Check if the current node is a leaf node
        if (root.left == null && root.right == null) {
          
            // Update the maximum sum if the
            // current path's sum is greater
            maxx = Math.Max(maxx, getSumOfPath(root, parent));
            return;
        }

        // If the left child exists, set the
        // current node as its parent and recurse
        if (root.left != null) {
            parent[root.left] = root;
            sumCal(root.left, ref maxx, parent);
        }

        // If the right child exists, set the
        // current node as its parent and recurse
        if (root.right != null) {
            parent[root.right] = root;
            sumCal(root.right, ref maxx, parent);
        }
    }

    // Function to return the maximum leaf-to-root 
  	// path sum in the binary tree
    static int maxPathSum(Node root) {
      
        // To store each node's parent for path calculation
        Dictionary<Node, Node> parent = 
          new Dictionary<Node, Node>();

        // Variable to store the maximum sum
        int maxx = 0;

        // Recursively calculate the sum for all paths
        sumCal(root, ref maxx, parent);

        // Return the maximum path sum found
        return maxx;
    }

    static void Main(string[] args) {
      
        // Constructing tree given
        //           10
        //         /    \
        //       -2      7
        //      /  \
        //     8   -4
        Node root = new Node(10);
        root.left = new Node(-2);
        root.right = new Node(7);
        root.left.left = new Node(8);
        root.left.right = new Node(-4);

        int sum = maxPathSum(root);
        Console.WriteLine(sum);
    }
}
JavaScript 
// JavaScript program to find maximum sum leaf to root
// path in Binary Tree by checking every path

class Node {
    constructor(x) {
        this.data = x;
        this.left = this.right = null;
    }
}

// Helper function to calculate the sum
// from a leaf node to the root
function getSumOfPath(root, parent) {

    // If the current node has no parent,
    // return its data (it's the root)
    if (!parent.has(root)) return root.data;

    // Recursively sum the current node data
    // with its parent's path sum
    return root.data + getSumOfPath(parent.get(root), parent);
}

// Function to calculate the maximum leaf-to-root path sum
function sumCal(root, maxx, parent) {

    // Check if the current node is a leaf node
    if (root.left === null && root.right === null) {
    
        // Update the maximum sum if the
        // current path's sum is greater
        maxx[0] = Math.max(maxx[0], getSumOfPath(root, parent));
        return;
    }

    // If the left child exists, set the
    // current node as its parent and recurse
    if (root.left !== null) {
        parent.set(root.left, root);
        sumCal(root.left, maxx, parent);
    }

    // If the right child exists, set the
    // current node as its parent and recurse
    if (root.right !== null) {
        parent.set(root.right, root);
        sumCal(root.right, maxx, parent);
    }
}

// Function to return the maximum leaf-to-root path 
// sum in the binary tree
function maxPathSum(root) {

    // To store each node's parent for path calculation
    let parent = new Map();

    // Variable to store the maximum sum
    let maxx = [0];

    // Recursively calculate the sum for all paths
    sumCal(root, maxx, parent);

    // Return the maximum path sum found
    return maxx[0];
}

// Constructing tree given
//           10
//         /    \
//       -2      7
//      /  \
//     8   -4
let root = new Node(10);
root.left = new Node(-2);
root.right = new Node(7);
root.left.left = new Node(8);
root.left.right = new Node(-4);

let sum = maxPathSum(root);
console.log(sum);

Output
17

Time Complexity: O(n * h) Where n is number of nodes in tree and h is height of tree.
Auxiliary Space: O(n)

[Expected Approach] By Keeping Track of Maximum Sum - O(n) Time and O(n) Space

The idea is to keep track of current sum and maximum sum while traversing the tree and update maximum sum if at leaf node current sum is greater them maximum sum.

Follow the steps below to solve the problem:

  • If the node is the root, return its data.
  • If the node is a leaf, Check where current sum is greater than maximum sum, then update maximum sum.
  • For non-leaf nodes, update current sum and make recursive call on both left and right child.

Below is the implementation of the above approach: 

C++ 
// CPP program to find maximum sum leaf to root
// path in Binary Tree

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;
  	Node(int x) {
     	data = x;
      	left = right = nullptr;
    }
};

// Helper function to find the leaf node that contributes
// to the maximum sum and returns the maximum sum from the
// root to that leaf
void findMaxSum(Node* root, int currSum, int& mxSum) {
    if (root == nullptr)
        return;

    // Add the current node's data to the path sum
    currSum += root->data;

    // Check if this node is a leaf node
    if (root->left == nullptr && root->right == nullptr) {
        
      	// Update the maximum sum and target 
      	// leaf if a higher sum is found
        if (currSum > mxSum) {
            mxSum = currSum;
        }
    }

    // Recursively check for the maximum sum 
  	// in the left and right subtrees
    findMaxSum(root->left, currSum, mxSum);
    findMaxSum(root->right, currSum, mxSum);
}

// Function to return the maximum sum
// path from root to leaf
int maxPathSum(Node* root) {
  
  	// empty tree has sum 0
    if (root == nullptr)
        return 0;  
	
  	// Initialize max sum as the smallest possible integer
    int mxSum = INT_MIN;        

    // Find the target leaf and maximum sum
    findMaxSum(root, 0, mxSum);

    // Return the maximum sum found
    return mxSum;
}
int main() {
  
    // Constructing tree:
    //           10
    //         /    \
    //       -2      7
    //      /  \
    //     8   -4
    Node *root = new Node(10);
    root->left = new Node(-2);
    root->right = new Node(7);
    root->left->left = new Node(8);
    root->left->right = new Node(-4);

    int sum = maxPathSum(root);
  	cout << sum << endl;
    return 0;
}
C 
// C program to find maximum sum leaf to
// root path in Binary Tree
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};


// Helper function to find the leaf node that contributes 
// to the maximum sum and returns the maximum sum from the
// root to that leaf
void findMaxSum(struct Node* root, int currSum, int* mxSum) {
    if (root == NULL)
        return;

    // Add the current node's data to the path sum
    currSum += root->data;

    // Check if this node is a leaf node
    if (root->left == NULL && root->right == NULL) {
        
        // Update the maximum sum if a higher sum is found
        if (currSum > *mxSum) {
            *mxSum = currSum;
        }
    }

    // Recursively check for the maximum 
  	// sum in the left and right subtrees
    findMaxSum(root->left, currSum, mxSum);
    findMaxSum(root->right, currSum, mxSum);
}

// Function to return the maximum sum path from root to leaf
int maxPathSum(struct Node* root) {

    // Empty tree has sum 0
    if (root == NULL)
        return 0;

    // Initialize max sum as the smallest possible integer
    int mxSum = INT_MIN;

    // Find the target leaf and maximum sum
    findMaxSum(root, 0, &mxSum);

    // Return the maximum sum found
    return mxSum;
}

struct Node* createNode(int data) {
    struct Node* newNode = 
      (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return newNode;
}

int main() {
  
    // Constructing tree:
    //           10
    //         /    \
    //       -2      7
    //      /  \
    //     8   -4
  
    struct Node* root = createNode(10);
    root->left = createNode(-2);
    root->right = createNode(7);
    root->left->left = createNode(8);
    root->left->right = createNode(-4);

    int sum = maxPathSum(root);
    printf("%d\n", sum);

    return 0;
}
Java 
// Java program to find maximum sum leaf to 
// root path in Binary Tree
class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Helper function to find the leaf node that contributes 
  	// to the maximum sum and returns the maximum sum from the
  	// root to that leaf
    static void findMaxSum(Node root, int currSum, int[] mxSum) {
        if (root == null)
            return;

        // Add the current node's data to the path sum
        currSum += root.data;

        // Check if this node is a leaf node
        if (root.left == null && root.right == null) {

            // Update the maximum sum if a higher sum is found
            if (currSum > mxSum[0]) {
                mxSum[0] = currSum;
            }
        }

        // Recursively check for the maximum sum 
      	// in the left and right subtrees
        findMaxSum(root.left, currSum, mxSum);
        findMaxSum(root.right, currSum, mxSum);
    }

    // Function to return the maximum sum path from root to leaf
    static int maxPathSum(Node root) {

        // Empty tree has sum 0
        if (root == null)
            return 0;

        // Initialize max sum as the smallest possible integer
        int[] mxSum = { Integer.MIN_VALUE };

        // Find the target leaf and maximum sum
        findMaxSum(root, 0, mxSum);

        // Return the maximum sum found
        return mxSum[0];
    }

    public static void main(String[] args) {
      
        // Constructing tree:
        //           10
        //         /    \
        //       -2      7
        //      /  \
        //     8   -4
        Node root = new Node(10);
        root.left = new Node(-2);
        root.right = new Node(7);
        root.left.left = new Node(8);
        root.left.right = new Node(-4);

        int sum = maxPathSum(root);
        System.out.println(sum);
    }
}
Python 
# Python program to find maximum sum leaf 
# to root path in Binary Tree

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Helper function to find the leaf node that contributes 
# to the maximum sum and returns the maximum sum from the 
# root to that leaf
def findMaxSum(root, currSum, mxSum):
    if root is None:
        return

    # Add the current node's data to the path sum
    currSum += root.data

    # Check if this node is a leaf node
    if root.left is None and root.right is None:
        
        # Update the maximum sum if a higher sum is found
        if currSum > mxSum[0]:
            mxSum[0] = currSum

    # Recursively check for the maximum sum
    # in the left and right subtrees
    findMaxSum(root.left, currSum, mxSum)
    findMaxSum(root.right, currSum, mxSum)

# Function to return the maximum sum path
# from root to leaf
def maxPathSum(root):

    # Empty tree has sum 0
    if root is None:
        return 0

    # Initialize max sum as the smallest possible integer
    mxSum = [-float('inf')]

    # Find the target leaf and maximum sum
    findMaxSum(root, 0, mxSum)

    # Return the maximum sum found
    return mxSum[0]

if __name__ == "__main__":
  
    # Constructing tree:
    #           10
    #         /    \
    #       -2      7
    #      /  \
    #     8   -4
    root = Node(10)
    root.left = Node(-2)
    root.right = Node(7)
    root.left.left = Node(8)
    root.left.right = Node(-4)

    sum = maxPathSum(root)
    print(sum)
C# 
// C# program to find maximum sum leaf 
// to root path in Binary Tree
using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Helper function to find the leaf node that contributes 
  	// to the maximum sum and returns the maximum sum from the
  	// root to that leaf
    static void findMaxSum(Node root, int currSum, ref int mxSum) {
        if (root == null)
            return;

        // Add the current node's data to the path sum
        currSum += root.data;

        // Check if this node is a leaf node
        if (root.left == null && root.right == null) {

            // Update the maximum sum if a higher sum is found
            if (currSum > mxSum) {
                mxSum = currSum;
            }
        }

        // Recursively check for the maximum 
      	// sum in the left and right subtrees
        findMaxSum(root.left, currSum, ref mxSum);
        findMaxSum(root.right, currSum, ref mxSum);
    }

    // Function to return the maximum sum path from root to leaf
    static int maxPathSum(Node root) {

        // Empty tree has sum 0
        if (root == null)
            return 0;

        // Initialize max sum as the smallest possible integer
        int mxSum = int.MinValue;

        // Find the target leaf and maximum sum
        findMaxSum(root, 0, ref mxSum);

        // Return the maximum sum found
        return mxSum;
    }

    static void Main() {
      
        // Constructing tree:
        //           10
        //         /    \
        //       -2      7
        //      /  \
        //     8   -4
        Node root = new Node(10);
        root.left = new Node(-2);
        root.right = new Node(7);
        root.left.left = new Node(8);
        root.left.right = new Node(-4);

        int sum = maxPathSum(root);
        Console.WriteLine(sum);
    }
}
JavaScript 
// JavaScript program to find maximum 
// sum leaf to root path in Binary Tree

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Helper function to find the leaf node that contributes 
// to the maximum sum and returns the maximum sum from the
// root to that leaf
function findMaxSum(root, currSum, mxSum) {
    if (root === null)
        return;

    // Add the current node's data to the path sum
    currSum += root.data;

    // Check if this node is a leaf node
    if (root.left === null && root.right === null) {

        // Update the maximum sum if a higher sum is found
        if (currSum > mxSum[0]) {
            mxSum[0] = currSum;
        }
    }

    // Recursively check for the maximum sum 
    // in the left and right subtrees
    findMaxSum(root.left, currSum, mxSum);
    findMaxSum(root.right, currSum, mxSum);
}

// Function to return the maximum sum path from
// root to leaf
function maxPathSum(root) {

    // Empty tree has sum 0
    if (root === null)
        return 0;

    // Initialize max sum as the smallest possible integer
    let mxSum = [-Infinity];

    // Find the target leaf and maximum sum
    findMaxSum(root, 0, mxSum);

    // Return the maximum sum found
    return mxSum[0];
}

// Constructing tree:
//           10
//         /    \
//       -2      7
//      /  \
//     8   -4
let root = new Node(10);
root.left = new Node(-2);
root.right = new Node(7);
root.left.left = new Node(8);
root.left.right = new Node(-4);

let sum = maxPathSum(root);
console.log(sum);

Output
17

Time Complexity: O(n) Where n is number of nodes in tree.
Auxiliary Space: O(n) , Function call stack space.

Comment
Article Tags:
Tree
DSA

Explore