Open in App
Not now

# Root to leaf path sum equal to a given number

• Difficulty Level : Medium
• Last Updated : 22 Aug, 2022

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

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

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

## 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)
Auxiliary Space: O(log N), stack space

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

My Personal Notes arrow_drop_up
Related Articles