Maximum Path Sum in a Binary Tree

02 Jul, 2021
Given a binary tree, find the maximum path sum. The path may start and end at any node in the tree.Example: 
Input: Root of below tree
       1
      / \
     2   3
Output: 6

See below diagram for another example.
1+2+3
 
 
For each node there can be four ways that the max path goes through the node: 1. Node only 2. Max path through Left Child + Node 3. Max path through Right Child + Node 4. Max path through Left Child + Node + Max path through Right ChildThe idea is to keep trace of four paths and pick up the max one in the end. An important thing to note is, root of every subtree need to return maximum path sum such that at most one child of root is involved. This is needed for parent function call. In below code, this sum is stored in ‘max_single’ and returned by the recursive function. 
C++
Java
Python
C#
Javascript
// C/C++ program to find maximum path sum in Binary Tree#include<bits/stdc++.h>using namespace std; // A binary tree nodestruct Node{    int data;    struct Node* left, *right;}; // A utility function to allocate a new nodestruct Node* newNode(int data){    struct Node* newNode = new Node;    newNode->data = data;    newNode->left = newNode->right = NULL;    return (newNode);} // This function returns overall maximum path sum in 'res'// And returns max path sum going through root.int findMaxUtil(Node* root, int &res){    //Base Case    if (root == NULL)        return 0;     // l and r store maximum path sum going through left and    // right child of root respectively    int l = findMaxUtil(root->left,res);    int r = findMaxUtil(root->right,res);     // Max path for parent call of root. This path must    // include at-most one child of root    int max_single = max(max(l, r) + root->data, root->data);     // Max Top represents the sum when the Node under    // consideration is the root of the maxsum path and no    // ancestors of root are there in max sum path    int max_top = max(max_single, l + r + root->data);     res = max(res, max_top); // Store the Maximum Result.     return max_single;} // Returns maximum path sum in tree with given rootint findMaxSum(Node *root){    // Initialize result    int res = INT_MIN;     // Compute and return result    findMaxUtil(root, res);    return res;} // Driver programint main(void){    struct Node *root = newNode(10);    root->left        = newNode(2);    root->right       = newNode(10);    root->left->left  = newNode(20);    root->left->right = newNode(1);    root->right->right = newNode(-25);    root->right->right->left   = newNode(3);    root->right->right->right  = newNode(4);    cout << "Max path sum is " << findMaxSum(root);    return 0;}
// Java program to find maximum path sum in Binary Tree /* Class containing left and right child of current node and key value*/class Node {     int data;    Node left, right;     public Node(int item) {        data = item;        left = right = null;    }} // An object of Res is passed around so that the// same value can be used by multiple recursive calls.class Res {    public int val;} class BinaryTree {     // Root of the Binary Tree    Node root;     // This function returns overall maximum path sum in 'res'    // And returns max path sum going through root.    int findMaxUtil(Node node, Res res)    {         // Base Case        if (node == null)            return 0;         // l and r store maximum path sum going through left and        // right child of root respectively        int l = findMaxUtil(node.left, res);        int r = findMaxUtil(node.right, res);         // Max path for parent call of root. This path must        // include at-most one child of root        int max_single = Math.max(Math.max(l, r) + node.data,                                  node.data);          // Max Top represents the sum when the Node under        // consideration is the root of the maxsum path and no        // ancestors of root are there in max sum path        int max_top = Math.max(max_single, l + r + node.data);         // Store the Maximum Result.        res.val = Math.max(res.val, max_top);         return max_single;    }     int findMaxSum() {        return findMaxSum(root);    }     // Returns maximum path sum in tree with given root    int findMaxSum(Node node) {         // Initialize result        // int res2 = Integer.MIN_VALUE;        Res res = new Res();        res.val = Integer.MIN_VALUE;         // Compute and return result        findMaxUtil(node, res);        return res.val;    }     /* Driver program to test above functions */    public static void main(String args[]) {        BinaryTree tree = new BinaryTree();        tree.root = new Node(10);        tree.root.left = new Node(2);        tree.root.right = new Node(10);        tree.root.left.left = new Node(20);        tree.root.left.right = new Node(1);        tree.root.right.right = new Node(-25);        tree.root.right.right.left = new Node(3);        tree.root.right.right.right = new Node(4);        System.out.println("maximum path sum is : " +                            tree.findMaxSum());    }}
# Python program to find maximum path sum in Binary Tree # A Binary Tree Nodeclass Node:         # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # This function returns overall maximum path sum in 'res'# And returns max path sum going through rootdef findMaxUtil(root):         # Base Case    if root is None:        return 0     # l and r store maximum path sum going through left    # and right child of root respectively    l = findMaxUtil(root.left)    r = findMaxUtil(root.right)         # Max path for parent call of root. This path    # must include at most one child of root    max_single = max(max(l, r) + root.data, root.data)         # Max top represents the sum when the node under    # consideration is the root of the maxSum path and    # no ancestor of root are there in max sum path    max_top = max(max_single, l+r+ root.data)     # Static variable to store the changes    # Store the maximum result    findMaxUtil.res = max(findMaxUtil.res, max_top)     return max_single # Return maximum path sum in tree with given rootdef findMaxSum(root):         # Initialize result    findMaxUtil.res = float("-inf")         # Compute and return result    findMaxUtil(root)    return findMaxUtil.res # Driver programroot = 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 "Max path sum is " ,findMaxSum(root); # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
// C# program to find maximum// path sum in Binary Treeusing System; /* Class containing left andright child of currentnode and key value*/public class Node{     public int data;    public Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} // An object of Res is passed// around so that the same value// can be used by multiple recursive calls.class Res{    public int val;} public class BinaryTree{     // Root of the Binary Tree    Node root;     // This function returns overall    // maximum path sum in 'res' And    // returns max path sum going through root.    int findMaxUtil(Node node, Res res)    {         // Base Case        if (node == null)            return 0;         // l and r store maximum path        // sum going through left and        // right child of root respectively        int l = findMaxUtil(node.left, res);        int r = findMaxUtil(node.right, res);         // Max path for parent call of root.        // This path must include        // at-most one child of root        int max_single = Math.Max(Math.Max(l, r) +                            node.data, node.data);          // Max Top represents the sum        // when the Node under        // consideration is the root        // of the maxsum path and no        // ancestors of root are there        // in max sum path        int max_top = Math.Max(max_single,                        l + r + node.data);         // Store the Maximum Result.        res.val = Math.Max(res.val, max_top);         return max_single;    }     int findMaxSum()    {        return findMaxSum(root);    }     // Returns maximum path    // sum in tree with given root    int findMaxSum(Node node)    {         // Initialize result        // int res2 = int.MinValue;        Res res = new Res();        res.val = int.MinValue;         // Compute and return result        findMaxUtil(node, res);        return res.val;    }     /* Driver code */    public static void Main(String []args)    {        BinaryTree tree = new BinaryTree();        tree.root = new Node(10);        tree.root.left = new Node(2);        tree.root.right = new Node(10);        tree.root.left.left = new Node(20);        tree.root.left.right = new Node(1);        tree.root.right.right = new Node(-25);        tree.root.right.right.left = new Node(3);        tree.root.right.right.right = new Node(4);        Console.WriteLine("maximum path sum is : " +                            tree.findMaxSum());    }} // This code is contributed Rajput-Ji.
<script>     // JavaScript program to find maximum    // path sum in Binary Tree         class Node    {        constructor(item) {           this.left = null;           this.right = null;           this.data = item;        }    }         let val;         // Root of the Binary Tree    let root;      // This function returns overall maximum path sum in 'res'    // And returns max path sum going through root.    function findMaxUtil(node)    {          // Base Case        if (node == null)            return 0;          // l and r store maximum path sum going through left and        // right child of root respectively        let l = findMaxUtil(node.left);        let r = findMaxUtil(node.right);          // Max path for parent call of root. This path must        // include at-most one child of root        let max_single = Math.max(Math.max(l, r) + node.data,                                  node.data);            // Max Top represents the sum when the Node under        // consideration is the root of the maxsum path and no        // ancestors of root are there in max sum path        let max_top = Math.max(max_single, l + r + node.data);          // Store the Maximum Result.        val = Math.max(val, max_top);          return max_single;    }      function findMaxsum() {        return findMaxSum(root);    }      // Returns maximum path sum in tree with given root    function findMaxSum(node) {          // Initialize result        // int res2 = Integer.MIN_VALUE;        val = Number.MIN_VALUE;          // Compute and return result        findMaxUtil(node);        return val;    }         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);    document.write("Max path sum is : " + findMaxsum());     </script>
Output:
Max path sum is 42
Time Complexity: O(n) where n is number of nodes in Binary Tree. 
Maximum Path Sum in a Binary Tree | GeeksforGeeks - YouTubeGeeksforGeeks530K subscribersMaximum Path Sum in a Binary Tree | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 5:10•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=cSnETAcziS0" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article is contributed by Anmol Varshney (FB Profile: https://www.facebook.com/anmolvarshney695). Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
Rajput-Ji
simmytarika5
suresh07
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Print Right View of a Binary Tree
Inorder Tree Traversal without Recursion
BFS vs DFS for Binary Tree
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Introduction to Data Structures
A program to check if a binary tree is BST or not
Introduction to Tree Data Structure
Decision Tree
Iterative Preorder Traversal