Open In App
Related Articles

Root to leaf path sum equal to a given number

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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 <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

// 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

// 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 <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;
}

                    

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<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);
        }
    }
}

                    

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<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);
        }
    }
}

                    

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



Last Updated : 28 Jul, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads