Maximum Path Sum in a Binary Tree

Last Updated : 03 Feb, 2025

Given a binary tree, the task is to find the maximum path sum. The path may start and end at any node in the tree.

Example:

Input:

Output: 42
Explanation: Max path sum is represented using green colour nodes in the above binary tree.
Input:

Output: 31
Explanation: Max path sum is represented using green colour nodes in the above binary tree.

Approach:

If the maximum sum path in a binary tree passes through the root, there are four possible cases to consider:
The path consists only the root itself, without involving any children.
The path starts at the root and extends downward through its right child, possibly continuing to the bottom of the right subtree.
The path starts at the root and extends downward through its left child, possibly continuing the bottom of the left subtree.
The path includes the root and spans both the left and right children.
The idea is to keep track of all four paths for each subtree of the tree and pick up the max one in the end.

Implementation:

For each subtree, we want to find the maximum path sum that starts at its root and goes down through either its left or right child. To do this, we create a recursive function (lets say MPS(current root)) that calculates and returns the maximum path sum starting from the root and extending downward through one of its children.

Within the same function, we can also calculate the maximum path sum for the current subtree and compare it with the final answer. This is done by combining the MPS(current root -> left) and MPS(current root -> right) with the value of the current root.

Note that if the MPS() from the left or right child is negative, we simply ignore it while calculating the maximum path sum for the current subtree.

C++

//Driver Code Starts // C++ program to find maximum path sum in Binary Tree #include <iostream> using namespace std;  class Node { public:     int data;     Node *left, *right;      // Constructor to initialize a new node     Node(int value) {         data = value;         left = nullptr;         right = nullptr;     } }; //Driver Code Ends   // Returns the maximum path sum in the subtree with the current node as an endpoint.  // Also updates 'res' with the maximum path sum. int maxPathSumUtil(Node* root, int& res) {        // Base case: return 0 for a null node     if (root == NULL)         return 0;      // Calculate maximum path sums for left and right subtrees     int l = max(0, maxPathSumUtil(root->left, res));     int r = max(0, maxPathSumUtil(root->right, res));      // Update 'res' with the maximum path sum passing through the current node     res = max(res, l + r + root->data);      // Return the maximum path sum rooted at this node     return root->data + max(l, r); }  // Returns maximum path sum in tree with given root int maxPathSum(Node* root) {     int res = root->data; 	   	// Compute maximum path sum and store it in 'res'     maxPathSumUtil(root, res);        return res; }   //Driver Code Starts int main() {   	 	// Representation of input binary tree:     //            10     //           /  \     //          2    10     //         / \     \       //        20  1    -25   	//                 /  \   	//				  3	   4     Node* root = new Node(10);     root->left = new Node(2);     root->right = new Node(10);     root->left->left = new Node(20);     root->left->right = new Node(1);     root->right->right = new Node(-25);     root->right->right->left = new Node(3);     root->right->right->right = new Node(4);      cout << maxPathSum(root);     return 0; } //Driver Code Ends

Java

//Driver Code Starts // Java program to find maximum path sum in Binary Tree class Node {     int data;     Node left, right;      // Constructor to initialize a new node     Node(int value) {         data = value;         left = null;         right = null;     } } //Driver Code Ends   class GfG {      // Returns the maximum path sum in the subtree with the current node as an endpoint.     // Also updates 'res' with the maximum path sum.     static int maxPathSumUtil(Node root, int[] res) {         // Base case: return 0 for a null node         if (root == null) return 0;          // Calculate maximum path sums for left and right subtrees         int l = Math.max(0, maxPathSumUtil(root.left, res));         int r = Math.max(0, maxPathSumUtil(root.right, res));          // Update 'res' with the maximum path sum passing through the current node         res[0] = Math.max(res[0], l + r + root.data);          // Return the maximum path sum rooted at this node         return root.data + Math.max(l, r);     }      // Returns maximum path sum in tree with given root     static int maxPathSum(Node root) {         int[] res = {root.data};          // Compute maximum path sum and store it in 'res'         maxPathSumUtil(root, res);          return res[0];     }   //Driver Code Starts     public static void main(String[] args) {         // Representation of input binary tree:         //            10         //           /  \         //          2    10         //         / \     \         //        20  1    -25         //                 /  \         //                3    4         Node root = new Node(10);         root.left = new Node(2);         root.right = new Node(10);         root.left.left = new Node(20);         root.left.right = new Node(1);         root.right.right = new Node(-25);         root.right.right.left = new Node(3);         root.right.right.right = new Node(4);          System.out.println(maxPathSum(root));     } }  //Driver Code Ends

Python

//Driver Code Starts # Python program to find maximum path sum in Binary Tree  class Node:     # Constructor to initialize a new node     def __init__(self, value):         self.data = value         self.left = None         self.right = None //Driver Code Ends   # Returns the maximum path sum in the subtree with the current node as an endpoint. # Also updates 'res' with the maximum path sum. def maxPathSumUtil(root, res):        # Base case: return 0 for a null node     if root is None:         return 0      # Calculate maximum path sums for left and right subtrees     l = max(0, maxPathSumUtil(root.left, res))     r = max(0, maxPathSumUtil(root.right, res))      # Update 'res' with the maximum path sum passing through the current node     res[0] = max(res[0], l + r + root.data)      # Return the maximum path sum rooted at this node     return root.data + max(l, r)  # Returns maximum path sum in tree with given root def maxPathSum(root):     res = [root.data]      # Compute maximum path sum and store it in 'res'     maxPathSumUtil(root, res)      return res[0]   //Driver Code Starts if __name__ == "__main__":     # Representation of input binary tree:     #            10     #           /  \     #          2    10     #         / \     \     #        20  1    -25     #                 /  \     #                3    4     root = Node(10)     root.left = Node(2)     root.right = Node(10)     root.left.left = Node(20)     root.left.right = Node(1)     root.right.right = Node(-25)     root.right.right.left = Node(3)     root.right.right.right = Node(4)      print(maxPathSum(root))  //Driver Code Ends

//Driver Code Starts // C# program to find maximum path sum in Binary Tree using System;  class Node {     public int data;     public Node left, right;      // Constructor to initialize a new node     public Node(int value) {         data = value;         left = null;         right = null;     } }  class GfG { //Driver Code Ends       // Returns the maximum path sum in the subtree with the current node as an endpoint.     // Also updates 'res' with the maximum path sum.     static int maxPathSumUtil(Node root, ref int res) {                // Base case: return 0 for a null node         if (root == null)             return 0;          // Calculate maximum path sums for left and right subtrees         int l = Math.Max(0, maxPathSumUtil(root.left, ref res));         int r = Math.Max(0, maxPathSumUtil(root.right, ref res));          // Update 'res' with the maximum path sum passing through the current node         res = Math.Max(res, l + r + root.data);          // Return the maximum path sum rooted at this node         return root.data + Math.Max(l, r);     }      // Returns maximum path sum in tree with given root     static int maxPathSum(Node root) {         int res = root.data;          // Compute maximum path sum and store it in 'res'         maxPathSumUtil(root, ref res);          return res;     }   //Driver Code Starts     static void Main(string[] args) {         // Representation of input binary tree:         //            10         //           /  \         //          2    10         //         / \     \         //        20  1    -25         //                 /  \         //                3    4         Node root = new Node(10);         root.left = new Node(2);         root.right = new Node(10);         root.left.left = new Node(20);         root.left.right = new Node(1);         root.right.right = new Node(-25);         root.right.right.left = new Node(3);         root.right.right.right = new Node(4);          Console.WriteLine(maxPathSum(root));     } }  //Driver Code Ends

JavaScript

//Driver Code Starts // JavaScript program to find maximum path sum in Binary Tree  class Node {     constructor(value) {         // Constructor to initialize a new node         this.data = value;         this.left = null;         this.right = null;     } } //Driver Code Ends   // Returns the maximum path sum in the subtree with the current node as an endpoint. // Also updates 'res' with the maximum path sum. function maxPathSumUtil(root, res) {      // Base case: return 0 for a null node     if (root === null) return 0;      // Calculate maximum path sums for left and right subtrees     const l = Math.max(0, maxPathSumUtil(root.left, res));     const r = Math.max(0, maxPathSumUtil(root.right, res));      // Update 'res' with the maximum path sum passing through the current node     res.value = Math.max(res.value, l + r + root.data);      // Return the maximum path sum rooted at this node     return root.data + Math.max(l, r); }  // Returns maximum path sum in tree with given root function maxPathSum(root) {     const res = { value: root.data };      // Compute maximum path sum and store it in 'res'     maxPathSumUtil(root, res);      return res.value; }   //Driver Code Starts // Driver Code // Representation of input binary tree: //            10 //           /  \ //          2    10 //         / \     \ //        20  1    -25 //                 /  \ //                3    4 const root = new Node(10); root.left = new Node(2); root.right = new Node(10); root.left.left = new Node(20); root.left.right = new Node(1); root.right.right = new Node(-25); root.right.right.left = new Node(3); root.right.right.right = new Node(4);  console.log(maxPathSum(root));  //Driver Code Ends