Open In App

# Root to leaf path sum equal to a given number

Given a binary tree and a number, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals the given number. Return false if no such path can be found.

Example:

Input:      10          Sum = 23
/     \
8        2
/    \     /
3      5  2

Output: True
Explanation:  Root to leaf path sum, existing in this tree are
21 –> 10 – 8 – 3
23 –> 10 – 8 – 5
14 –> 10 – 2 – 2
So it is possible to get sum = 23

Recommended Practice

Recursively move to left and right subtree and decrease sum by the value of the current node and if at any point the current node is equal to a leaf node and remaining sum is equal to zero then the answer is true

Follow the given steps to solve the problem using the above approach:

• Recursively move to the left and right subtree and at each call decrease the sum by the value of the current node
• If at any level the current node is a leaf node and the remaining sum is equal to zero then return true

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `#define bool int` `/* A binary tree node has data, pointer to left child``and a pointer to right child */``class` `node {``public``:``    ``int` `data;``    ``node* left;``    ``node* right;``};` `/*``Given a tree and a sum, return true if there is a path from``the root down to a leaf, such that adding up all the values``along the path equals the given sum.` `Strategy: subtract the node value from the sum when``recurring down, and check to see if the sum is 0 when you``when you reach the leaf node.``*/``bool` `hasPathSum(node* Node, ``int` `sum)``{``    ``if` `(Node == NULL)``        ``return` `0;` `    ``bool` `ans = 0;` `    ``int` `subSum = sum - Node->data;` `    ``/* If we reach a leaf node and sum becomes 0 then return``     ``* true*/``    ``if` `(subSum == 0 && Node->left == NULL``        ``&& Node->right == NULL)``        ``return` `1;` `    ``/* otherwise check both subtrees */``    ``if` `(Node->left)``        ``ans = ans || hasPathSum(Node->left, subSum);``    ``if` `(Node->right)``        ``ans = ans || hasPathSum(Node->right, subSum);` `    ``return` `ans;``}` `/* UTILITY FUNCTIONS */``/* Helper function that allocates a new node with the``given data and NULL left and right pointers. */``node* newnode(``int` `data)``{``    ``node* Node = ``new` `node();``    ``Node->data = data;``    ``Node->left = NULL;``    ``Node->right = NULL;` `    ``return` `(Node);``}` `// Driver's Code``int` `main()``{` `    ``int` `sum = 21;` `    ``/* Constructed binary tree is``                ``10``            ``/ \``            ``8 2``        ``/ \ /``        ``3 5 2``    ``*/``    ``node* root = newnode(10);``    ``root->left = newnode(8);``    ``root->right = newnode(2);``    ``root->left->left = newnode(3);``    ``root->left->right = newnode(5);``    ``root->right->left = newnode(2);``    ` `      ``// Function call``    ``if` `(hasPathSum(root, sum))``        ``cout << ``"There is a root-to-leaf path with sum "``             ``<< sum;``    ``else``        ``cout << ``"There is no root-to-leaf path with sum "``             ``<< sum;` `    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `// C program for the above approach` `#include ``#include ``#define bool int` `/* 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;``};` `/*`` ``Given a tree and a sum, return`` ``true if there is a path from`` ``the root down to a leaf, such`` ``that adding up all the values`` ``along the path equals the given sum.` ` ``Strategy: subtract the node`` ``value from the sum when`` ``recurring down, and check to`` ``see if the sum is 0 when you reach the leaf node.``*/``bool` `hasPathSum(``struct` `node* node, ``int` `sum)``{``    ``if` `(node == NULL)``        ``return` `0;``    ``bool` `ans = 0;` `    ``int` `subSum = sum - node->data;` `    ``/* If we reach a leaf node``          ``and sum becomes 0 then``           ``* return true*/``    ``if` `(subSum == 0 && node->left == NULL``        ``&& node->right == NULL)``        ``return` `1;` `    ``/* otherwise check both subtrees */``    ``if` `(node->left)``        ``ans = ans || hasPathSum(node->left, subSum);``    ``if` `(node->right)``        ``ans = ans || hasPathSum(node->right, subSum);` `    ``return` `ans;``}` `/* 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``        ``= (``struct` `node*)``malloc``(``sizeof``(``struct` `node));``    ``node->data = data;``    ``node->left = NULL;``    ``node->right = NULL;` `    ``return` `(node);``}` `// Driver's Code``int` `main()``{` `    ``int` `sum = 21;` `    ``/* Constructed binary tree is``              ``10``            ``/   \``          ``8      2``        ``/  \    /``      ``3     5  2``    ``*/``    ``struct` `node* root = newnode(10);``    ``root->left = newnode(8);``    ``root->right = newnode(2);``    ``root->left->left = newnode(3);``    ``root->left->right = newnode(5);``    ``root->right->left = newnode(2);` `    ``// Function call``    ``if` `(hasPathSum(root, sum))``        ``printf``(``"There is a root-to-leaf path with sum %d"``,``               ``sum);``    ``else``        ``printf``(``"There is no root-to-leaf path with sum %d"``,``               ``sum);` `    ``getchar``();``    ``return` `0;``}`

## Java

 `// Java program to print``// root to leaf path sum``// equal to a given number` `/* A binary tree node has data,`` ``pointer to left child``   ``and a pointer to right child */``class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `class` `BinaryTree {` `    ``Node root;` `    ``/*``     ``Given a tree and a sum,``     ``return true if there is a path``     ``from the root down to a leaf,``     ``such that adding up all``     ``the values along the path``     ``equals the given sum.` `     ``Strategy: subtract the node``     ``value from the sum when``     ``recurring down, and check to``     ``see if the sum is 0 you reach the leaf node.``     ``*/` `    ``boolean` `hasPathSum(Node node, ``int` `sum)``    ``{``        ``/* If the tree is empty there is no way the reqd sum``         ``* will be there. */``        ``if` `(root == ``null``)``            ``return` `false``;``        ``boolean` `ans = ``false``;``        ``int` `subSum = sum - node.data;``        ``if` `(subSum == ``0` `&& node.left == ``null``            ``&& node.right == ``null``)``            ``return` `(ans = ``true``);``        ``if` `(node.left != ``null``)` `            ``// ans || hasPathSum... has no utility if the``            ``// ans is false``            ``ans = ans || hasPathSum(node.left, subSum);` `        ``if` `(node.right != ``null``)` `            ``// But if it is true then we can avoid calling``            ``// hasPathSum here as answer has already been``            ``// found``            ``ans = ans || hasPathSum(node.right, subSum);``        ``return` `(ans);``    ``}` `    ``// Driver's Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `sum = ``21``;` `        ``/* Constructed binary tree is``              ``10``             ``/  \``           ``8     2``          ``/ \   /``         ``3   5 2``        ``*/``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``10``);``        ``tree.root.left = ``new` `Node(``8``);``        ``tree.root.right = ``new` `Node(``2``);``        ``tree.root.left.left = ``new` `Node(``3``);``        ``tree.root.left.right = ``new` `Node(``5``);``        ``tree.root.right.left = ``new` `Node(``2``);``        ` `          ``// Function call``        ``if` `(tree.hasPathSum(tree.root, sum))``            ``System.out.println(``                ``"There is a root to leaf path with sum "``                ``+ sum);``        ``else``            ``System.out.println(``                ``"There is no root to leaf path with sum "``                ``+ sum);``    ``}``}` `// This code has been contributed by Mayank``// Jaiswal(mayank_24)`

## Python3

 `# Python3 program to find if``# there is a root to sum path` `# 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`  `"""`` ``Given a tree and a sum, return`` ``true if there is a path from the root`` ``down to a leaf, such that`` ``adding up all the values along the path`` ``equals the given sum.`` ` ` ``Strategy: subtract the node`` ``value from the sum when recurring down,`` ``and check to see if the sum`` ``is 0 when you run out of tree.``"""``# s is the sum`  `def` `hasPathSum(node, s):``    ``ans ``=` `0``    ``subSum ``=` `s ``-` `node.data` `    ``# If we reach a leaf node and sum becomes 0, then``    ``# return True``    ``if``(subSum ``=``=` `0` `and` `node.left ``=``=` `None` `and` `node.right ``=``=` `None``):``        ``return` `True` `    ``# Otherwise check both subtrees``    ``if` `node.left ``is` `not` `None``:``        ``ans ``=` `ans ``or` `hasPathSum(node.left, subSum)``    ``if` `node.right ``is` `not` `None``:``        ``ans ``=` `ans ``or` `hasPathSum(node.right, subSum)` `    ``return` `ans` `# Driver's Code``if` `__name__ ``=``=` `"__main__"``:``    ``s ``=` `21``    ``root ``=` `Node(``10``)``    ``root.left ``=` `Node(``8``)``    ``root.right ``=` `Node(``2``)``    ``root.left.right ``=` `Node(``5``)``    ``root.left.left ``=` `Node(``3``)``    ``root.right.left ``=` `Node(``2``)``    ` `    ``# Function call``    ``if` `hasPathSum(root, s):``        ``print``(``"There is a root-to-leaf path with sum %d"` `%` `(s))``    ``else``:``        ``print``(``"There is no root-to-leaf path with sum %d"` `%` `(s))` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `// C# program to print root to``// leaf path sum equal to a given number``using` `System;` `/* 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, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `class` `GFG {``    ``public` `Node root;` `    ``/*``    ``Given a tree and a sum, return true if``    ``there is a path from the root down to a``    ``leaf, such that adding up all the values``    ``along the path equals the given sum.` `    ``Strategy: subtract the node value from the``    ``sum when recurring down, and check to see``    ``if the sum is 0 when you you reach the leaf node..``    ``*/` `    ``public` `virtual` `bool` `haspathSum(Node node, ``int` `sum)``    ``{``        ``ans = ``false``;` `        ``int` `subsum = sum - node.data;``        ``if` `(subsum == 0 && node.left == ``null``            ``&& node.right == ``null``) {``            ``return` `true``;``        ``}` `        ``/* otherwise check both subtrees */``        ``if` `(node.left != ``null``) {``            ``ans = ans || haspathSum(node.left, subsum);``        ``}``        ``if` `(node.right != ``null``) {``            ``ans = ans || haspathSum(node.right, subsum);``        ``}``        ``return` `ans;``    ``}` `    ``// Driver's Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int` `sum = 21;` `        ``/* Constructed binary tree is``            ``10``            ``/ \``        ``8     2``        ``/ \ /``        ``3 5 2``        ``*/``        ``GFG tree = ``new` `GFG();``        ``tree.root = ``new` `Node(10);``        ``tree.root.left = ``new` `Node(8);``        ``tree.root.right = ``new` `Node(2);``        ``tree.root.left.left = ``new` `Node(3);``        ``tree.root.left.right = ``new` `Node(5);``        ``tree.root.right.left = ``new` `Node(2);` `          ``// Function call``        ``if` `(tree.haspathSum(tree.root, sum)) {``            ``Console.WriteLine(``"There is a root to leaf "``                              ``+ ``"path with sum "` `+ sum);``        ``}``        ``else` `{``            ``Console.WriteLine(``"There is no root to leaf "``                              ``+ ``"path with sum "` `+ sum);``        ``}``    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 `// javascript program to print``// root to leaf path sum``// equal to a given number` `/* A binary tree node has data,`` ``pointer to left child``   ``and a pointer to right child */` `class Node {``        ``constructor(val) {``            ``this``.data = val;``            ``this``.left = ``null``;``            ``this``.right = ``null``;``        ``}``    ``}` `var` `root;` `    ``/*``     ``Given a tree and a sum,``     ``return true if there is a path``     ``from the root down to a leaf,``     ``such that adding up all``     ``the values along the path``     ``equals the given sum.` `     ``Strategy: subtract the node``     ``value from the sum when``     ``recurring down, and check to``     ``see if the sum is 0 you reach the leaf node.``     ``*/` `    ``function` `hasPathSum(node , sum)``    ``{``      ``var` `ans = ``false``;``      ``var` `subSum = sum - node.data;``      ``if``(subSum == 0 && node.left == ``null` `&& node.right == ``null``)``        ``return``(ans = ``true``);``      ``if``(node.left != ``null``) ``        ` `        ``// ans || hasPathSum... has no utility if the ans is false``        ``ans = ans || hasPathSum(node.left, subSum);       ``     ` `      ``if``(node.right != ``null``)``        ` `        ``// But if it is true then we can afunction calling hasPathSum``        ``// here as answer has already been found``        ``ans = ans || hasPathSum(node.right, subSum);   ``      ``return``(ans);``    ``}` `    ``// Driver Code` `        ``var` `sum = 21;` `        ``/* Constructed binary tree is``              ``10``             ``/  \``           ``8     2``          ``/ \   /``         ``3   5 2``        ``*/` `        ``var` `root = ``new` `Node(10);``        ``root.left = ``new` `Node(8);``        ``root.right = ``new` `Node(2);``        ``root.left.left = ``new` `Node(3);``        ``root.left.right = ``new` `Node(5);``        ``root.right.left = ``new` `Node(2);` `        ``if` `(hasPathSum(root, sum))``            ``document.write(``                ``"There is a root to leaf path with sum "``                ``+ sum);``        ``else``            ``document.write(``                ``"There is no root to leaf path with sum "``                ``+ sum);` `// This code is contributed by gauravrajput1`

Output

```There is a root-to-leaf path with sum 21

```

Time Complexity: O(N)

Space Complexity: O(N) or O(H)

Approach 2: Iterative Approach using Stack
In this approach, we use a stack to perform a preorder traversal of the binary tree. We maintain two stacks – one to store the nodes and another to store the sum of values along the path to that node. Whenever we encounter a leaf node, we check if the sum matches the target sum. If it does, we return true, otherwise, we continue traversing the tree.

• Check if the root node is NULL. If it is, return false, since there is no path to follow.
• Create two stacks, one for the nodes and one for the sums. Push the root node onto the node stack and its data onto the sum stack.
• While the node stack is not empty, do the following:
• Pop a node from the node stack and its corresponding sum from the sum stack.
•  Check if the node is a leaf node (i.e., it has no left or right child). If it is, check if the sum equals the target sum. If it does, return true, since we have found a path that adds up to the target sum.
•  If the node has a left child, push it onto the node stack and push the sum plus the left child’s data onto the sum stack.
• If the node has a right child, push it onto the node stack and push the sum plus the right child’s data onto the sum stack.
• If we reach this point, it means we have exhausted all paths and haven’t found any that add up to the target sum. Return false.

## C++

 `#include ``using` `namespace` `std;` `struct` `Node {``    ``int` `data;``    ``Node* left, *right;``    ``Node(``int` `val) {``        ``data = val;``        ``left = right = NULL;``    ``}``};` `bool` `hasPathSum(Node* root, ``int` `targetSum) {``    ``if` `(root == NULL) ``return` `false``;``    ``stack s;``    ``stack<``int``> sums;``    ``s.push(root);``    ``sums.push(root->data);``    ``while` `(!s.empty()) {``        ``Node* node = s.top(); s.pop();``        ``int` `sum = sums.top(); sums.pop();``        ``if` `(node->left == NULL && node->right == NULL) {``            ``if` `(sum == targetSum) ``return` `true``;``        ``}``        ``if` `(node->left != NULL) {``            ``s.push(node->left);``            ``sums.push(sum + node->left->data);``        ``}``        ``if` `(node->right != NULL) {``            ``s.push(node->right);``            ``sums.push(sum + node->right->data);``        ``}``    ``}``    ``return` `false``;``}` `int` `main() {``    ``Node* root = ``new` `Node(10);``    ``root->left = ``new` `Node(8);``    ``root->right = ``new` `Node(2);``    ``root->left->left = ``new` `Node(3);``    ``root->left->right = ``new` `Node(5);``    ``root->right->left = ``new` `Node(2);``   `  `    ``int` `targetSum = 23;``    ``if` `(hasPathSum(root, targetSum)) {``          ``cout << ``"There is a root-to-leaf path with sum "``             ``<< targetSum;``    ``}``    ``else` `{``          ``cout << ``"There is no root-to-leaf path with sum "``             ``<< targetSum;``    ``}``    ``return` `0;``}`

## Java

 `import` `java.util.Stack;` `class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``Node(``int` `val) {``        ``data = val;``        ``left = right = ``null``;``    ``}``}` `public` `class` `PathSum {``    ``public` `static` `boolean` `hasPathSum(Node root, ``int` `targetSum) {``        ``if` `(root == ``null``)``            ``return` `false``;` `        ``Stack stack = ``new` `Stack<>();``        ``Stack sums = ``new` `Stack<>();``        ``stack.push(root);``        ``sums.push(root.data);` `        ``while` `(!stack.isEmpty()) {``            ``Node node = stack.pop();``            ``int` `sum = sums.pop();` `            ``if` `(node.left == ``null` `&& node.right == ``null``) {``                ``if` `(sum == targetSum)``                    ``return` `true``;``            ``}` `            ``if` `(node.left != ``null``) {``                ``stack.push(node.left);``                ``sums.push(sum + node.left.data);``            ``}``            ``if` `(node.right != ``null``) {``                ``stack.push(node.right);``                ``sums.push(sum + node.right.data);``            ``}``        ``}` `        ``return` `false``;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``Node root = ``new` `Node(``10``);``        ``root.left = ``new` `Node(``8``);``        ``root.right = ``new` `Node(``2``);``        ``root.left.left = ``new` `Node(``3``);``        ``root.left.right = ``new` `Node(``5``);``        ``root.right.left = ``new` `Node(``2``);` `        ``int` `targetSum = ``23``;``        ``if` `(hasPathSum(root, targetSum)) {``            ``System.out.println(``"There is a root-to-leaf path with sum "` `+ targetSum);``        ``} ``else` `{``            ``System.out.println(``"There is no root-to-leaf path with sum "` `+ targetSum);``        ``}``    ``}``}`

## Python3

 `class` `Node:``    ``def` `__init__(``self``, val):``        ``self``.data ``=` `val``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `def` `hasPathSum(root, targetSum):``    ``if` `not` `root:``        ``return` `False``    ``s ``=` `[root]``    ``sums ``=` `[root.data]``    ``while` `s:``        ``node ``=` `s.pop()``        ``sum_val ``=` `sums.pop()``        ``if` `not` `node.left ``and` `not` `node.right:``            ``if` `sum_val ``=``=` `targetSum:``                ``return` `True``        ``if` `node.left:``            ``s.append(node.left)``            ``sums.append(sum_val ``+` `node.left.data)``        ``if` `node.right:``            ``s.append(node.right)``            ``sums.append(sum_val ``+` `node.right.data)``    ``return` `False` `if` `__name__ ``=``=` `'__main__'``:``    ``root ``=` `Node(``10``)``    ``root.left ``=` `Node(``8``)``    ``root.right ``=` `Node(``2``)``    ``root.left.left ``=` `Node(``3``)``    ``root.left.right ``=` `Node(``5``)``    ``root.right.left ``=` `Node(``2``)` `    ``targetSum ``=` `23``    ``if` `hasPathSum(root, targetSum):``        ``print``(``"There is a root-to-leaf path with sum"``, targetSum)``    ``else``:``        ``print``(``"There is no root-to-leaf path with sum"``, targetSum)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `val)``    ``{``        ``data = val;``        ``left = right = ``null``;``    ``}``}` `public` `class` `PathSum``{``    ``public` `static` `bool` `HasPathSum(Node root, ``int` `targetSum)``    ``{``        ``if` `(root == ``null``)``            ``return` `false``;` `        ``Stack stack = ``new` `Stack();``        ``Stack<``int``> sums = ``new` `Stack<``int``>();``        ``stack.Push(root);``        ``sums.Push(root.data);` `        ``while` `(stack.Count > 0)``        ``{``            ``Node node = stack.Pop();``            ``int` `sum = sums.Pop();` `            ``if` `(node.left == ``null` `&& node.right == ``null``)``            ``{``                ``if` `(sum == targetSum)``                    ``return` `true``;``            ``}` `            ``if` `(node.left != ``null``)``            ``{``                ``stack.Push(node.left);``                ``sums.Push(sum + node.left.data);``            ``}``            ``if` `(node.right != ``null``)``            ``{``                ``stack.Push(node.right);``                ``sums.Push(sum + node.right.data);``            ``}``        ``}` `        ``return` `false``;``    ``}` `    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``Node root = ``new` `Node(10);``        ``root.left = ``new` `Node(8);``        ``root.right = ``new` `Node(2);``        ``root.left.left = ``new` `Node(3);``        ``root.left.right = ``new` `Node(5);``        ``root.right.left = ``new` `Node(2);` `        ``int` `targetSum = 23;``        ``if` `(HasPathSum(root, targetSum))``        ``{``            ``Console.WriteLine(``"There is a root-to-leaf path with sum "` `+ targetSum);``        ``}``        ``else``        ``{``            ``Console.WriteLine(``"There is no root-to-leaf path with sum "` `+ targetSum);``        ``}``    ``}``}`

## Javascript

 `class Node {``    ``constructor(val) {``        ``this``.data = val;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}` `function` `hasPathSum(root, targetSum) {``    ``if` `(root === ``null``) {``        ``return` `false``;``    ``}` `    ``const stack = [];``    ``const sums = [];``    ``stack.push(root);``    ``sums.push(root.data);` `    ``while` `(stack.length > 0) {``        ``const node = stack.pop();``        ``const sum = sums.pop();` `        ``if` `(node.left === ``null` `&& node.right === ``null``) {``            ``if` `(sum === targetSum) {``                ``return` `true``;``            ``}``        ``}` `        ``if` `(node.left !== ``null``) {``            ``stack.push(node.left);``            ``sums.push(sum + node.left.data);``        ``}``        ``if` `(node.right !== ``null``) {``            ``stack.push(node.right);``            ``sums.push(sum + node.right.data);``        ``}``    ``}` `    ``return` `false``;``}` `const root = ``new` `Node(10);``root.left = ``new` `Node(8);``root.right = ``new` `Node(2);``root.left.left = ``new` `Node(3);``root.left.right = ``new` `Node(5);``root.right.left = ``new` `Node(2);` `const targetSum = 23;``if` `(hasPathSum(root, targetSum)) {``    ``console.log(``"There is a root-to-leaf path with sum "` `+ targetSum);``} ``else` `{``    ``console.log(``"There is no root-to-leaf path with sum "` `+ targetSum);``}`

Output

```There is a root-to-leaf path with sum 23

```

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

References: http://cslibrary.stanford.edu/110/BinaryTrees.html
Author: Tushar Roy
Please write comments if you find any bug in above code/algorithm, or find other ways to solve the same problem