# Root to leaf path sum equal to a given number in BST

• Difficulty Level : Easy
• Last Updated : 31 Aug, 2022

Given a BST and a number. The task is to check whether the given number is equal to the sum of all the node from root leaf across any of the root to leaf paths in the given Binary Search Tree

Approach: The idea is to traverse from root to all leaves in top-down fashion maintaining a path[] array to store current root to leaf path. While traversing, store data of all nodes of current path in the array path[]. Whenever a leaf node is reached, calculate the sum of all of the nodes on the current path using the array path[] and check if it is equal to the given sum.

Below is the implementation of above approach:

## C++

 `// CPP program to check if root to leaf path` `// sum to a given number in BST`   `#include` `using` `namespace` `std;`   `// BST node` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `};`   `/* Helper function that allocates a new node */` `Node* newNode(``int` `data) ` `{ ` `    ``Node* node = (Node*)``malloc``(``sizeof``(Node)); ` `    ``node->data = data; ` `    ``node->left = node->right = NULL; ` `    ``return` `(node); ` `} `   `// Function to check if root to leaf path` `// sum to a given number in BST` `int` `checkThesum(``struct` `Node *root, ``int` `path[], ``int` `i, ``int` `sum)` `{` `    ``int` `sum1 = 0, x, y, j;` `    `  `    ``if``(root == NULL)` `        ``return` `0;` `        `  `    ``// insert the data of a node` `    ``path[i] = root->data;` `    `  `    ``// if the node is leaf` `    ``// add all the element in array` `    ``if``(root->left==NULL&&root->right==NULL)` `    ``{` `        ``for``(j = 0; j <= i; j++)` `            ``sum1 = sum1 + path[j];` `            `  `        ``// if the sum of root node to leaf ` `        ``// node data is equal then return 1` `        ``if``(sum == sum1)` `            ``return` `1;` `        ``else` `            ``return` `0;` `    ``}`   `    ``x = checkThesum(root->left, path, i+1, sum);` `    `  `    ``// if x is 1, it means the given sum is matched ` `    ``// with root to leaf node sum` `    ``if``(x==1) ` `        ``return` `1;` `    ``else` `    ``{` `        ``return` `checkThesum(root->right, path, i+1, sum);` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `path[100], sum = 164;` `    `  `    ``Node *root = newNode(45);` `    ``root->left = newNode(38);` `    ``root->left->left = newNode(33);` `    ``root->left->left->left = newNode(31);` `    ``root->left->left->right = newNode(35);` `    ``root->left->right = newNode(41);` `    ``root->left->right->left = newNode(40);` `    ``root->left->right->right = newNode(44);` `    ``root->right = newNode(50);` `    ``root->right->left = newNode(47);` `    ``root->right->left->left = newNode(46);` `    ``root->right->left->right = newNode(48);` `    ``root->right->right = newNode(52);` `    ``root->right->right->left = newNode(51);` `    ``root->right->right->right = newNode(55);` `    `  `    ``if``(checkThesum(root, path, 0, sum)==1)` `        ``cout<<``"YES\n"``;` `    ``else` `        ``cout<<``"NO\n"``;` `        `  `    ``return` `0;` `} `

## Java

 `// Java program to check if ` `// root to leaf path sum to` `// a given number in BST` `class` `GFG` `{` `    `  `// BST node` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}`   `/* Helper function that ` `   ``allocates a new node */` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node node = ``new` `Node(); ` `    ``node.data = data; ` `    ``node.left = node.right = ``null``; ` `    ``return` `(node); ` `} `   `// Function to check if root ` `// to leaf path sum to a` `// given number in BST` `static` `int` `checkThesum(Node root, ``int` `path[],` `                           ``int` `i, ``int` `sum)` `{` `    ``int` `sum1 = ``0``, x, y, j;` `    `  `    ``if``(root == ``null``)` `        ``return` `0``;` `        `  `    ``// insert the data of a node` `    ``path[i] = root.data;` `    `  `    ``// if the node is leaf` `    ``// add all the element in array` `    ``if``(root.left == ``null` `&& ` `       ``root.right == ``null``)` `    ``{` `        ``for``(j = ``0``; j <= i; j++)` `            ``sum1 = sum1 + path[j];` `            `  `        ``// if the sum of root node to leaf ` `        ``// node data is equal then return 1` `        ``if``(sum == sum1)` `            ``return` `1``;` `        ``else` `            ``return` `0``;` `    ``}`   `    ``x = checkThesum(root.left, path, ` `                        ``i + ``1``, sum);` `    `  `    ``// if x is 1, it means the ` `    ``// given sum is matched with ` `    ``// root to leaf node sum` `    ``if``(x == ``1``) ` `        ``return` `1``;` `    ``else` `    ``{` `        ``return` `checkThesum(root.right, path,` `                                ``i + ``1``, sum);` `    ``}` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``int` `path[] = ``new` `int``[``100``], sum = ``164``;` `    `  `    ``Node root = newNode(``45``);` `    ``root.left = newNode(``38``);` `    ``root.left.left = newNode(``33``);` `    ``root.left.left.left = newNode(``31``);` `    ``root.left.left.right = newNode(``35``);` `    ``root.left.right = newNode(``41``);` `    ``root.left.right.left = newNode(``40``);` `    ``root.left.right.right = newNode(``44``);` `    ``root.right = newNode(``50``);` `    ``root.right.left = newNode(``47``);` `    ``root.right.left.left = newNode(``46``);` `    ``root.right.left.right = newNode(``48``);` `    ``root.right.right = newNode(``52``);` `    ``root.right.right.left = newNode(``51``);` `    ``root.right.right.right = newNode(``55``);` `    `  `    ``if``(checkThesum(root, path, ``0``, sum) == ``1``)` `        ``System.out.print(``"YES\n"``);` `    ``else` `        ``System.out.print(``"NO\n"``);` `} ` `}`   `// This code is contributed by Arnab Kundu `

## Python3

 `# Python program to check if root to leaf path` `# sum to a given number in BST` `import` `math`   `# BST node` `class` `Node: ` `    ``def` `__init__(``self``,data): ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right``=` `None`   `# Helper function that allocates a new node */` `def` `newNode(data): ` `    ``node ``=` `Node(data) ` `    ``node.data ``=` `data ` `    ``node.left ``=` `None` `    ``node.right ``=` `None`   `    ``return` `node `   `# Function to check if root to leaf path` `# sum to a given number in BST` `def` `checkThesum(root, path, i, ``sum``):` `    ``sum1 ``=` `0` `    `  `    ``# x, y, j ` `    ``if``(root ``=``=` `None``):` `        ``return` `0` `        `  `    ``# insert the data of a node` `    ``path[i] ``=` `root.data` `    `  `    ``# if the node is leaf` `    ``# add all the element in array` `    ``if``(root.left ``=``=` `None` `and` `root.right ``=``=` `None``):` `        ``for` `j ``in` `range``(``0``, i ``+` `1``):` `            ``sum1 ``=` `sum1 ``+` `path[j]` `            `  `        ``# if the sum of root node to leaf ` `        ``# node data is equal then return 1` `        ``if``(``sum` `=``=` `sum1):` `            ``return` `1` `        ``else``:` `            ``return` `0` `    `  `    ``x ``=` `checkThesum(root.left, path, i ``+` `1``, ``sum``)` `    `  `    ``# if x is 1, it means the given sum is matched ` `    ``# with root to leaf node sum` `    ``if``(x ``=``=` `1``):` `        ``return` `1` `    ``else``:` `        ``return` `checkThesum(root.right, path, i ``+` `1``, ``sum``)` `    `  `# Driver code` `if` `__name__``=``=``'__main__'``: `   `    ``path ``=` `[``None``] ``*` `100` `    ``sum` `=` `164` `    `  `    ``root ``=` `newNode(``45``)` `    ``root.left ``=` `newNode(``38``)` `    ``root.left.left ``=` `newNode(``33``)` `    ``root.left.left.left ``=` `newNode(``31``)` `    ``root.left.left.right ``=` `newNode(``35``)` `    ``root.left.right ``=` `newNode(``41``)` `    ``root.left.right.left ``=` `newNode(``40``)` `    ``root.left.right.right ``=` `newNode(``44``)` `    ``root.right ``=` `newNode(``50``)` `    ``root.right.left ``=` `newNode(``47``)` `    ``root.right.left.left ``=` `newNode(``46``)` `    ``root.right.left.right ``=` `newNode(``48``)` `    ``root.right.right ``=` `newNode(``52``)` `    ``root.right.right.left ``=` `newNode(``51``)` `    ``root.right.right.right ``=` `newNode(``55``)` `    `  `    ``if``(checkThesum(root, path, ``0``, ``sum``) ``=``=` `1``):` `        ``print``(``"YES"``)` `    ``else``:` `        ``print``(``"NO"``)` `        `  `# This code is contributed by Srathore`

## C#

 `// C# program to check if ` `// root to leaf path sum to ` `// a given number in BST ` `using` `System;`   `class` `GFG ` `{ ` `    `  `// BST node ` `public` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `} `   `/* Helper function that ` `allocates a new node */` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node node = ``new` `Node(); ` `    ``node.data = data; ` `    ``node.left = node.right = ``null``; ` `    ``return` `(node); ` `} `   `// Function to check if root ` `// to leaf path sum to a ` `// given number in BST ` `static` `int` `checkThesum(Node root, ``int` `[]path, ` `                        ``int` `i, ``int` `sum) ` `{ ` `    ``int` `sum1 = 0, x, y, j; ` `    `  `    ``if``(root == ``null``) ` `        ``return` `0; ` `        `  `    ``// insert the data of a node ` `    ``path[i] = root.data; ` `    `  `    ``// if the node is leaf ` `    ``// add all the element in array ` `    ``if``(root.left == ``null` `&& ` `    ``root.right == ``null``) ` `    ``{ ` `        ``for``(j = 0; j <= i; j++) ` `            ``sum1 = sum1 + path[j]; ` `            `  `        ``// if the sum of root node to leaf ` `        ``// node data is equal then return 1 ` `        ``if``(sum == sum1) ` `            ``return` `1; ` `        ``else` `            ``return` `0; ` `    ``} `   `    ``x = checkThesum(root.left, path, ` `                        ``i + 1, sum); ` `    `  `    ``// if x is 1, it means the ` `    ``// given sum is matched with ` `    ``// root to leaf node sum ` `    ``if``(x == 1) ` `        ``return` `1; ` `    ``else` `    ``{ ` `        ``return` `checkThesum(root.right, path, ` `                                ``i + 1, sum); ` `    ``} ` `} `   `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``int` `[]path = ``new` `int``[100];``int` `sum = 164; ` `    `  `    ``Node root = newNode(45); ` `    ``root.left = newNode(38); ` `    ``root.left.left = newNode(33); ` `    ``root.left.left.left = newNode(31); ` `    ``root.left.left.right = newNode(35); ` `    ``root.left.right = newNode(41); ` `    ``root.left.right.left = newNode(40); ` `    ``root.left.right.right = newNode(44); ` `    ``root.right = newNode(50); ` `    ``root.right.left = newNode(47); ` `    ``root.right.left.left = newNode(46); ` `    ``root.right.left.right = newNode(48); ` `    ``root.right.right = newNode(52); ` `    ``root.right.right.left = newNode(51); ` `    ``root.right.right.right = newNode(55); ` `    `  `    ``if``(checkThesum(root, path, 0, sum) == 1) ` `        ``Console.Write(``"YES\n"``); ` `    ``else` `        ``Console.Write(``"NO\n"``); ` `} ` `} `   `// This code is contributed 29AjayKumar`

## Javascript

 ``

Output

```YES
```

Complexity Analysis:

• Time complexity: O(n) where n is no of nodes in given BST
• Auxiliary Space: O(n)

My Personal Notes arrow_drop_up
Related Articles