# Shortest root to leaf path sum equal to a given number

Given a binary tree and a number, the task is to return the length of the shortest path beginning at root and ending at a leaf node such that the sum of numbers along that path is equal to ‘sum’. Print “-1” if no such path exists.

Examples:

```Input:
1
/       \
10         15
/      \
5        2
Number = 16
Output: 2

There are two paths:
1->15, length of path is 3
1->10->5, length of path is 2

Input:
1
/       \
10         15
/      \
5        2
Number = 20
Output: -1
There exists no such path with 20 as sum from root to any node
```

Source: Microsoft Interview

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: An approach to check whether such a path exists or not has been discussed in this post. The below steps can be followed to find the shortest path.

• Recursively call the left and right child with path sum and level to ( number – value at the current node, level+1).
• If the leaf node is reached, then store the minimum of all the levels of the leaf node.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `/* A binary tree node has data, pointer to left child  ` `and a pointer to right child */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* left; ` `    ``struct` `Node* right; ` `}; ` ` `  `// Function to find the shortes path from root ` `// to leaf with given sum ` `void` `hasPathSum(``struct` `Node* node, ``int` `sum, ` `                ``int``& mini, ``int` `level) ` `{ ` `    ``// went beyond tree ` `    ``if` `(node == NULL) ` `        ``return``; ` `    ``int` `subSum = sum - (node->data); ` `    ``if` `(node->left == NULL && node->right == NULL) { ` `        ``// Store the minimum path ` `        ``if` `(subSum == 0) ` `            ``mini = min(level - 1, mini); ` `        ``return``; ` `    ``} ` ` `  `    ``else` `{ ` `        ``// Recur in the left tree ` `        ``hasPathSum(node->left, subSum, mini, level + 1); ` ` `  `        ``// Recur in the right tree ` `        ``hasPathSum(node->right, subSum, mini, level + 1); ` `    ``} ` `} ` ` `  `/* UTILITY FUNCTIONS */` `/* Helper function that allocates a new node with the  ` `given data and NULL left and right pointers. */` `struct` `Node* newnode(``int` `data) ` `{ ` `    ``struct` `Node* node = ``new` `Node; ` `    ``node->data = data; ` `    ``node->left = NULL; ` `    ``node->right = NULL; ` ` `  `    ``return` `(node); ` `} ` ` `  `/* Driver program to test above functions*/` `int` `main() ` `{ ` ` `  `    ``int` `sum = 16; ` ` `  `    ``/* Constructed binary tree is  ` `         `  `                 ``1 ` `             ``/       \  ` `          ``10         15  ` `       ``/      \      ` `     ``5        2  ` `*/` `    ``struct` `Node* root = newnode(1); ` `    ``root->left = newnode(10); ` `    ``root->right = newnode(15); ` `    ``root->left->left = newnode(5); ` `    ``root->left->right = newnode(2); ` ` `  `    ``int` `mini = INT_MAX; ` ` `  `    ``// Function call ` `    ``hasPathSum(root, sum, mini, 0); ` ` `  `    ``if` `(mini != INT_MAX) ` `        ``printf``(``"There is a root-to-leaf path with sum %d\n"` `               ``"and the shortest path length is: %d"``, ` `               ``sum, mini + 1); ` `    ``else` `        ``printf``(``"There is no root-to-leaf path with sum %d"``, sum); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach  ` `class` `GFG  ` `{ ` ` `  `static` `int` `mini; ` ` `  `/* A binary tree node has data, pointer to left child  ` `and a pointer to right child */` `static` `class` `Node ` `{  ` `    ``int` `data;  ` `    ``Node left;  ` `    ``Node right;  ` `};  ` ` `  `// Function to find the shortes path from root  ` `// to leaf with given sum  ` `static` `void` `hasPathSum(Node node, ``int` `sum,  ` `                ``int` `level)  ` `{  ` `    ``// went beyond tree  ` `    ``if` `(node == ``null``)  ` `        ``return``;  ` `    ``int` `subSum = sum - (node.data);  ` `    ``if` `(node.left == ``null` `&& node.right == ``null``)  ` `    ``{  ` `        ``// Store the minimum path  ` `        ``if` `(subSum == ``0``)  ` `            ``mini = Math.min(level - ``1``, mini);  ` `        ``return``;  ` `    ``}  ` ` `  `    ``else`  `    ``{  ` `        ``// Recur in the left tree  ` `        ``hasPathSum(node.left, subSum, level + ``1``);  ` ` `  `        ``// Recur in the right tree  ` `        ``hasPathSum(node.right, subSum, level + ``1``);  ` `    ``}  ` `}  ` ` `  `/* UTILITY FUNCTIONS */` `/* Helper function that allocates a new node with the  ` `given data and null left and right pointers. */` `static` `Node newnode(``int` `data)  ` `{  ` `    ``Node node = ``new` `Node();  ` `    ``node.data = data;  ` `    ``node.left = ``null``;  ` `    ``node.right = ``null``;  ` ` `  `    ``return` `(node);  ` `}  ` ` `  `/* Driver code*/` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `sum = ``16``;  ` ` `  `    ``/* Constructed binary tree is  ` `         `  `                ``1  ` `            ``/ \  ` `        ``10     15  ` `    ``/ \  ` `    ``5 2  ` `*/` `    ``Node root = newnode(``1``);  ` `    ``root.left = newnode(``10``);  ` `    ``root.right = newnode(``15``);  ` `    ``root.left.left = newnode(``5``);  ` `    ``root.left.right = newnode(``2``);  ` ` `  `    ``mini = Integer.MAX_VALUE;  ` ` `  `    ``// Function call  ` `    ``hasPathSum(root, sum, ``0``);  ` ` `  `    ``if` `(mini != Integer.MAX_VALUE)  ` `        ``System.out.printf(``"There is a root-to-leaf path with sum %d\n"` `            ``+``"and the shortest path length is: %d"` `                        ``,sum, mini + ``1``);  ` `    ``else` `        ``System.out.printf(``"There is no root-to-leaf path with sum %d"``, sum); ` ` `  `    ``} ` `} ` ` `  `// This code is contributed by Princi Singh `

## Python3

 `# Python3 implementation of the above approach  ` ` `  `INT_MAX ``=` `2147483647` ` `  `""" A binary tree node has data, pointer  ` `to left child and a pointer to right child """` ` `  `"""UTILITY FUNCTIONS  ` `Helper function that allocates a new node  ` `with the given data and NULL left and right  ` `pointers."""` `class` `newnode:  ` ` `  `    ``# Construct to create a newNode  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.data ``=` `key  ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Function to find the shortes path  ` `# from root to leaf with given summ  ` `def` `hasPathSum(node, summ, mini, level) :  ` ` `  `    ``# check if leaf node and check summ  ` `    ``if` `(node ``=``=` `None``) :  ` `        ``return` `    ``subsumm ``=` `summ ``-` `node.data ` `     `  `    ``if``(node.left ``=``=` `None` `and` `node.right ``=``=` `None``):  ` `        ``# Store the minimum path  ` `        ``if` `(subsumm ``=``=` `0``) :  ` `            ``mini[``0``] ``=` `min``(level ``-` `1``, mini[``0``])  ` `        ``return` `     `  `    ``else``:  ` `         `  ` `  `        ``# Recur in the left tree  ` `        ``hasPathSum(node.left, subsumm,  ` `                    ``mini, level ``+` `1``)  ` ` `  `        ``# Recur in the right tree  ` `        ``hasPathSum(node.right, subsumm,  ` `                    ``mini, level ``+` `1``)  ` `     `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``:  ` ` `  `    ``summ ``=` `16` ` `  `    ``""" Constructed binary tree is  ` `         `  `                ``1  ` `            ``/     \  ` `        ``10         15  ` `         `  `    ``/     \           \ ` `    ``5     2         15 ` `    ``"""` `    ``root ``=` `newnode(``1``)  ` `    ``root.left ``=` `newnode(``10``)  ` `    ``root.right ``=` `newnode(``15``) ` `    ``root.left.left ``=` `newnode(``5``)  ` `    ``root.left.right ``=` `newnode(``2``)  ` ` `  `    ``mini ``=` `[INT_MAX]  ` ` `  `    ``# Function call  ` `    ``hasPathSum(root, summ, mini, ``0``)  ` ` `  `    ``if` `(mini[``0``] !``=` `INT_MAX) :  ` `        ``print``(``"There is a root-to-leaf path"``,  ` `                        ``"with sum"``, summ)  ` `        ``print``(``"and the shortest path length is:"``,  ` `                                        ``mini[``0``] ``+` `1``)  ` `    ``else``:  ` `        ``print``(``"There is no root-to-leaf path"``,  ` `                            ``"with sum "``, summ)  ` ` `  `# This code is contributed by  ` `# Shubham Singh(SHUBHAMSINGH10)  `

## C#

 `// C# implementation of the above approach ` `using` `System; ` `     `  `class` `GFG  ` `{ ` ` `  `static` `int` `mini; ` ` `  `/* A binary tree node has data, pointer to left child  ` `and a pointer to right child */` `public` `class` `Node ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left;  ` `    ``public` `Node right;  ` `};  ` ` `  `// Function to find the shortes path from root  ` `// to leaf with given sum  ` `static` `void` `hasPathSum(Node node, ``int` `sum,  ` `                ``int` `level)  ` `{  ` `    ``// went beyond tree  ` `    ``if` `(node == ``null``)  ` `        ``return``;  ` `    ``int` `subSum = sum - (node.data);  ` `    ``if` `(node.left == ``null` `&& node.right == ``null``)  ` `    ``{  ` `        ``// Store the minimum path  ` `        ``if` `(subSum == 0)  ` `            ``mini = Math.Min(level - 1, mini);  ` `        ``return``;  ` `    ``}  ` ` `  `    ``else` `    ``{  ` `        ``// Recur in the left tree  ` `        ``hasPathSum(node.left, subSum, level + 1);  ` ` `  `        ``// Recur in the right tree  ` `        ``hasPathSum(node.right, subSum, level + 1);  ` `    ``}  ` `}  ` ` `  `/* UTILITY FUNCTIONS */` `/* Helper function that allocates a new node with the  ` `given data and null left and right pointers. */` `static` `Node newnode(``int` `data)  ` `{  ` `    ``Node node = ``new` `Node();  ` `    ``node.data = data;  ` `    ``node.left = ``null``;  ` `    ``node.right = ``null``;  ` ` `  `    ``return` `(node);  ` `}  ` ` `  `/* Driver code*/` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `sum = 16;  ` ` `  `    ``/* Constructed binary tree is  ` `         `  `                ``1  ` `            ``/ \  ` `        ``10     15  ` `    ``/ \  ` `    ``5 2  ` `*/` `    ``Node root = newnode(1);  ` `    ``root.left = newnode(10);  ` `    ``root.right = newnode(15);  ` `    ``root.left.left = newnode(5);  ` `    ``root.left.right = newnode(2);  ` ` `  `    ``mini = ``int``.MaxValue;  ` ` `  `    ``// Function call  ` `    ``hasPathSum(root, sum, 0);  ` ` `  `    ``if` `(mini != ``int``.MaxValue)  ` `        ``Console.Write(``"There is a root-to-leaf path with sum {0}\n"` `            ``+``"and the shortest path length is: {1}"` `                        ``,sum, mini + 1);  ` `    ``else` `        ``Console.Write(``"There is no root-to-leaf path with sum {0}"``, sum); ` ` `  `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```There is a root-to-leaf path with sum 16
and the shortest path length is: 1
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

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