# 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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next