Minimum sum path between two leaves of a binary tree

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:  
Minimum root to leaf path sum for the subtree rooted under current node.The minimum path sum between leaves.
Minimum root to leaf path sum for the subtree rooted under current node.
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++
Java
Python3
C#
Javascript
// C++ program to find minimum path sum// between two leaves of a binary tree#include <bits/stdc++.h>using namespace std; // A binary tree nodestruct Node {    int data;    struct Node* left;    struct Node* right;}; // Utility function to allocate memory// for a new nodestruct 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_MINint 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 leavesint minPathSum(struct Node* root){    int result = INT_MAX;    minPathSumUtil(root, result);    return result;} // Driver codeint 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 program to find minimum path sum// between two leaves of a binary treeclass GFG{     // A binary tree nodestatic class Node{    int data;    Node left;    Node right;}; // Utility function to allocate memory// for a new nodestatic 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_MINstatic 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 leavesstatic int minPathSum( Node root){    result = Integer.MAX_VALUE;    minPathSumUtil(root);    return result;}  // Driver codepublic 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 program to find minimum path sum# between two leaves of a binary tree     # Tree nodeclass Node:    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Utility function to allocate memory# for a new nodedef 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_MINdef 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 leavesdef minPathSum( root):    global result    result = 9999999    minPathSumUtil(root)    return result # Driver coderoot = 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# program to find minimum path sum// between two leaves of a binary treeusing System;     class GFG{     // A binary tree nodepublic class Node{    public int data;    public Node left;    public Node right;}; // Utility function to allocate memory// for a new nodestatic 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_MINstatic 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 leavesstatic int minPathSum( Node root){    result = int.MaxValue;    minPathSumUtil(root);    return result;}  // Driver codepublic 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
<script>     // JavaScript program to find minimum path sum    // between two leaves of a binary tree         // Structure of binary tree    class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }         // Utility function to allocate memory    // for a new node    function newNode(data)    {        let node = new Node(data);        return (node);    }    let 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    function minPathSumUtil(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        let ls = minPathSumUtil(root.left);        let 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    function minPathSum(root)    {        result = Number.MAX_VALUE;        minPathSumUtil(root);        return result;    }         let 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);       document.write(minPathSum(root));     </script>
1
 
Time Complexity: O(N) Auxiliary Space: O(N)
andrew1234
29AjayKumar
divyesh072019
pankajsharmagfg
Binary Tree
Data Structures
Tree
Data Structures
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
What is Hashing | A Complete Tutorial
Find if there is a path between two vertices in an undirected graph
What is Data Structure: Types, Classifications and Applications
TCS NQT Coding Sheet
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Introduction to Data Structures