# Maximum Path Sum in a Binary Tree

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``` ## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 Child

The 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++

 `// C/C++ program to find maximum path sum in Binary Tree ` `#include ` `using` `namespace` `std; ` ` `  `// A binary tree node ` `struct` `Node ` `{ ` `    ``int` `data; ` `    ``struct` `Node* left, *right; ` `}; ` ` `  `// A utility function to allocate a new node ` `struct` `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 root ` `int` `findMaxSum(Node *root) ` `{ ` `    ``// Initialize result ` `    ``int` `res = INT_MIN; ` ` `  `    ``// Compute and return result ` `    ``findMaxUtil(root, res); ` `    ``return` `res; ` `} ` ` `  `// Driver program ` `int` `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

 `// 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

 `# Python program to find maximum path sum in Binary Tree ` ` `  `# A Binary Tree Node ` `class` `Node: ` `     `  `    ``# Contructor 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 root ` `def` `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 respetively ` `    ``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 root ` `def` `findMaxSum(root): ` `     `  `    ``# Initialize result ` `    ``findMaxUtil.res ``=` `float``(``"-inf"``) ` `     `  `    ``# Compute and return result ` `    ``findMaxUtil(root) ` `    ``return` `findMaxUtil.res ` ` `  `# Driver program  ` `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` `"Max path sum is "` `,findMaxSum(root); ` ` `  `# This code is contributed by Nikhil Kumar Singh(nickzuck_007) `

## C#

 `// C# program to find maximum  ` `// path sum in Binary Tree ` `using` `System; ` ` `  `/* Class containing left and ` `right child of current ` `node 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.  `

Output:

`Max path sum is 42`

Time Complexity: O(n) where n is number of nodes in Binary Tree.

My Personal Notes arrow_drop_up

Improved By : Rajput-Ji

Article Tags :
Practice Tags :

24

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.