 Open in App
Not now

# Minimum sum path between two leaves of a binary tree

• Difficulty Level : Hard
• Last Updated : 06 Aug, 2021

Given a binary tree in which each node element contains a number. The task is to find the minimum possible sum from one leaf node to another.
If one side of root is empty, then function should return minus infinite.
Examples:

```Input :
4
/  \
5    -6
/ \   / \
2  -3 1   8
Output : 1
The minimum sum path between two leaf nodes is:
-3 -> 5 -> 4 -> -6 -> 1

Input :
3
/  \
2    4
/ \
-5  1
Output : -2```

Approach: The idea is to maintain two values in recursive calls:

1. Minimum root to leaf path sum for the subtree rooted under current node.
2. The minimum path sum between leaves.

For every visited node X, we find the minimum root to leaf sum in left and right sub trees of X. We add the two values with X’s data, and compare the sum with the current minimum path sum.
Below is the implementation of the above approach:

## C++

 `// C++ program to find minimum path sum``// between two leaves of a binary tree``#include ``using` `namespace` `std;` `// A binary tree node``struct` `Node {``    ``int` `data;``    ``struct` `Node* left;``    ``struct` `Node* right;``};` `// Utility function to allocate memory``// for a new node``struct` `Node* newNode(``int` `data)``{``    ``struct` `Node* node = ``new` `(``struct` `Node);``    ``node->data = data;``    ``node->left = node->right = NULL;` `    ``return` `(node);``}` `// A utility function to find the minimum sum between``// any two leaves. This function calculates two values:``// 1. Minimum path sum between two leaves which is stored``// in result and,``// 2. The minimum root to leaf path sum which is returned.``// If one side of root is empty, then it returns INT_MIN``int` `minPathSumUtil(``struct` `Node* root, ``int``& result)``{``    ``// Base cases``    ``if` `(root == NULL)``        ``return` `0;` `    ``if` `(root->left == NULL && root->right == NULL)``        ``return` `root->data;` `    ``// Find minimum sum in left and right sub tree. Also``    ``// find minimum root to leaf sums in left and right``    ``// sub trees and store them in ls and rs``    ``int` `ls = minPathSumUtil(root->left, result);``    ``int` `rs = minPathSumUtil(root->right, result);` `    ``// If both left and right children exist``    ``if` `(root->left && root->right) {``        ``// Update result if needed``        ``result = min(result, ls + rs + root->data);` `        ``// Return minimum possible value for root being``        ``// on one side``        ``return` `min(ls + root->data, rs + root->data);``    ``}` `    ``// If any of the two children is empty, return``    ``// root sum for root being on one side``    ``if` `(root->left == NULL)``        ``return` `rs + root->data;``    ``else``        ``return` `ls + root->data;``}` `// Function to return the minimum``// sum path between two leaves``int` `minPathSum(``struct` `Node* root)``{``    ``int` `result = INT_MAX;``    ``minPathSumUtil(root, result);``    ``return` `result;``}` `// Driver code``int` `main()``{``    ``struct` `Node* root = newNode(4);``    ``root->left = newNode(5);``    ``root->right = newNode(-6);``    ``root->left->left = newNode(2);``    ``root->left->right = newNode(-3);``    ``root->right->left = newNode(1);``    ``root->right->right = newNode(8);` `    ``cout << minPathSum(root);` `    ``return` `0;``}`

## Java

 `// Java program to find minimum path sum``// between two leaves of a binary tree``class` `GFG``{``    ` `// A binary tree node``static` `class` `Node``{``    ``int` `data;``    ``Node left;``    ``Node right;``};` `// Utility function to allocate memory``// for a new node``static` `Node newNode(``int` `data)``{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = node.right = ``null``;` `    ``return` `(node);``}``static` `int` `result;` `// A utility function to find the minimum sum between``// any two leaves. This function calculates two values:``// 1. Minimum path sum between two leaves which is stored``// in result and,``// 2. The minimum root to leaf path sum which is returned.``// If one side of root is empty, then it returns INT_MIN``static` `int` `minPathSumUtil( Node root)``{``    ``// Base cases``    ``if` `(root == ``null``)``        ``return` `0``;` `    ``if` `(root.left == ``null` `&& root.right == ``null``)``        ``return` `root.data;` `    ``// Find minimum sum in left and right sub tree. Also``    ``// find minimum root to leaf sums in left and right``    ``// sub trees and store them in ls and rs``    ``int` `ls = minPathSumUtil(root.left);``    ``int` `rs = minPathSumUtil(root.right);` `    ``// If both left and right children exist``    ``if` `(root.left != ``null` `&& root.right != ``null``)``    ``{``        ``// Update result if needed``        ``result = Math.min(result, ls + rs + root.data);` `        ``// Return minimum possible value for root being``        ``// on one side``        ``return` `Math.min(ls + root.data, rs + root.data);``    ``}` `    ``// If any of the two children is empty, return``    ``// root sum for root being on one side``    ``if` `(root.left == ``null``)``        ``return` `rs + root.data;``    ``else``        ``return` `ls + root.data;``}` `// Function to return the minimum``// sum path between two leaves``static` `int` `minPathSum( Node root)``{``    ``result = Integer.MAX_VALUE;``    ``minPathSumUtil(root);``    ``return` `result;``}`  `// Driver code``public` `static` `void` `main(String args[])``{``    ``Node root = newNode(``4``);``    ``root.left = newNode(``5``);``    ``root.right = newNode(-``6``);``    ``root.left.left = newNode(``2``);``    ``root.left.right = newNode(-``3``);``    ``root.right.left = newNode(``1``);``    ``root.right.right = newNode(``8``);` `    ``System.out.print(minPathSum(root));``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to find minimum path sum``# between two leaves of a binary tree``    ` `# Tree node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Utility function to allocate memory``# for a new node``def` `newNode( data):` `    ``node ``=` `Node(``0``)``    ``node.data ``=` `data``    ``node.left ``=` `node.right ``=` `None` `    ``return` `(node)` `result ``=` `-``1` `# A utility function to find the``# minimum sum between any two leaves.``# This function calculates two values:``# 1. Minimum path sum between two leaves ``# which is stored in result and,``# 2. The minimum root to leaf path sum``# which is returned.``# If one side of root is empty,``# then it returns INT_MIN``def` `minPathSumUtil(root) :``    ``global` `result``    ` `    ``# Base cases``    ``if` `(root ``=``=` `None``):``        ``return` `0` `    ``if` `(root.left ``=``=` `None` `and``        ``root.right ``=``=` `None``) :``        ``return` `root.data` `    ``# Find minimum sum in left and right sub tree.``    ``# Also find minimum root to leaf sums in``    ``# left and right sub trees and store them``    ``# in ls and rs``    ``ls ``=` `minPathSumUtil(root.left)``    ``rs ``=` `minPathSumUtil(root.right)` `    ``# If both left and right children exist``    ``if` `(root.left !``=` `None` `and``        ``root.right !``=` `None``) :``    ` `        ``# Update result if needed``        ``result ``=` `min``(result, ls ``+``                     ``rs ``+` `root.data)` `        ``# Return minimum possible value for``        ``# root being on one side``        ``return` `min``(ls ``+` `root.data,``                   ``rs ``+` `root.data)``    ` `    ``# If any of the two children is empty,``    ``# return root sum for root being on one side``    ``if` `(root.left ``=``=` `None``) :``        ``return` `rs ``+` `root.data``    ``else``:``        ``return` `ls ``+` `root.data` `# Function to return the minimum``# sum path between two leaves``def` `minPathSum( root):``    ``global` `result``    ``result ``=` `9999999``    ``minPathSumUtil(root)``    ``return` `result` `# Driver code``root ``=` `newNode(``4``)``root.left ``=` `newNode(``5``)``root.right ``=` `newNode(``-``6``)``root.left.left ``=` `newNode(``2``)``root.left.right ``=` `newNode(``-``3``)``root.right.left ``=` `newNode(``1``)``root.right.right ``=` `newNode(``8``)` `print``(minPathSum(root))` `# This code is contributed``# by Arnab Kundu`

## C#

 `// C# program to find minimum path sum``// between two leaves of a binary tree``using` `System;``    ` `class` `GFG``{``    ` `// A binary tree node``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left;``    ``public` `Node right;``};` `// Utility function to allocate memory``// for a new node``static` `Node newNode(``int` `data)``{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = node.right = ``null``;` `    ``return` `(node);``}``static` `int` `result;` `// A utility function to find the minimum sum between``// any two leaves. This function calculates two values:``// 1. Minimum path sum between two leaves which is stored``// in result and,``// 2. The minimum root to leaf path sum which is returned.``// If one side of root is empty, then it returns INT_MIN``static` `int` `minPathSumUtil( Node root)``{``    ``// Base cases``    ``if` `(root == ``null``)``        ``return` `0;` `    ``if` `(root.left == ``null` `&& root.right == ``null``)``        ``return` `root.data;` `    ``// Find minimum sum in left and right sub tree. Also``    ``// find minimum root to leaf sums in left and right``    ``// sub trees and store them in ls and rs``    ``int` `ls = minPathSumUtil(root.left);``    ``int` `rs = minPathSumUtil(root.right);` `    ``// If both left and right children exist``    ``if` `(root.left != ``null` `&& root.right != ``null``)``    ``{``        ``// Update result if needed``        ``result = Math.Min(result, ls + rs + root.data);` `        ``// Return minimum possible value for root being``        ``// on one side``        ``return` `Math.Min(ls + root.data, rs + root.data);``    ``}` `    ``// If any of the two children is empty, return``    ``// root sum for root being on one side``    ``if` `(root.left == ``null``)``        ``return` `rs + root.data;``    ``else``        ``return` `ls + root.data;``}` `// Function to return the minimum``// sum path between two leaves``static` `int` `minPathSum( Node root)``{``    ``result = ``int``.MaxValue;``    ``minPathSumUtil(root);``    ``return` `result;``}`  `// Driver code``public` `static` `void` `Main(String []args)``{``    ``Node root = newNode(4);``    ``root.left = newNode(5);``    ``root.right = newNode(-6);``    ``root.left.left = newNode(2);``    ``root.left.right = newNode(-3);``    ``root.right.left = newNode(1);``    ``root.right.right = newNode(8);` `Console.Write(minPathSum(root));``}``}` `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output:

`1`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up