# Maximum Path Sum in a Binary Tree

• Difficulty Level : Hard
• Last Updated : 23 Sep, 2022

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

Input:

Binary tree

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

Approach: To solve the problem follow the below idea:

For each node there can be four ways that the max path goes through the node:

• Node only
• Max path through Left Child + Node
• Max path through Right Child + Node
• Max path through Left Child + Node + Max path through Right Child

The idea is to keep track of four paths and pick up the max one in the end. An important thing to note is, that the root of every subtree needs to return the maximum path sum such that at most one child of the root is involved. This is needed for the parent function call. In the below code, this sum is stored in ‘max_single’ and returned by the recursive function.

Follow the given steps to solve the problem:

• If the root is NULL, return 0(Base Case)
• Call the recursive function to find the max sum for the left and the right subtree
• In a variable store the maximum of (root->data, maximum of (leftSum, rightSum) + root->data)
• In another variable store the maximum of previous step and root->data + leftSum + rightSum
• Return the maximum of the previous step

Below is the implementation of the above approach:

## 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 code``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);` `    ``// Function call``    ``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 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``);` `        ``// Function call``        ``System.out.println(``"maximum path sum is : "``                           ``+ tree.findMaxSum());``    ``}``}`

## Python

 `# Python3 program to find maximum path sum in Binary Tree` `# A Binary Tree Node`  `class` `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 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 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 root`  `def` `findMaxSum(root):` `    ``# Initialize result``    ``findMaxUtil.res ``=` `float``(``"-inf"``)` `    ``# Compute and return result``    ``findMaxUtil(root)``    ``return` `findMaxUtil.res`  `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``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``)` `    ``# Function call``    ``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);` `        ``// Function call``        ``Console.WriteLine(``"maximum path sum is : "``                          ``+ tree.findMaxSum());``    ``}``}` `// This code is contributed Rajput-Ji.`

## Javascript

 ``

Output

`Max path sum is 42`

Time Complexity: O(N) where N is the number of nodes in the Binary Tree
Auxiliary Space: O(N)