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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to check if root to leaf path
// sum to a given number in BST
  
#include<bits/stdc++.h>
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;

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

YES


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : andrew1234, 29AjayKumar