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 2Output: 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
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:
#include <bits/stdc++.h> 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 program for the above approach #include <stdio.h> #include <stdlib.h> #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 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 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# 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 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 |
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.
#include <bits/stdc++.h> 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<Node*> 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;
} |
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<Node> stack = new Stack<>();
Stack<Integer> 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);
}
}
} |
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)
|
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<Node> stack = new Stack<Node>();
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);
}
}
} |
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);
} |
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