Count subtrees that sum up to a given value x only using single recursive function

Difficulty Level : Easy
Last Updated : 01 Dec, 2020

Given a binary tree containing n nodes. The problem is to count subtrees having total node’s data sum equal to a given value using only single recursive functions.

Examples:

Input : 
             5
           /   \  
        -10     3
        /  \   /  \
       9    8 -4   7
       
       x = 7

Output : 2
There are 2 subtrees with sum 7.

1st one is leaf node:
7.

2nd one is:

      -10
     /   \
    9     8

Source: Microsoft Interview Experience | Set 157.

Approach:

countSubtreesWithSumX(root, count, x)
    if !root then
        return 0
        
    ls = countSubtreesWithSumX(root->left, count, x)
    rs = countSubtreesWithSumX(root->right, count, x)
    sum = ls + rs + root->data
    
    if sum == x then
    count++
    return sum

countSubtreesWithSumXUtil(root, x)
    if !root then
        return 0
    
    Initialize count = 0
    ls = countSubtreesWithSumX(root->left, count, x)
    rs = countSubtreesWithSumX(root->right, count, x)
    
    if (ls + rs + root->data) == x
        count++
    return count

C++

// C++ implementation to count subtress that
// sum up to a given value x
#include <bits/stdc++.h>
 
using namespace std;
 
// structure of a node of binary tree
struct Node {
    int data;
    Node *left, *right;
};
 
// function to get a new node
Node* getNode(int data)
{
    // allocate space
    Node* newNode = (Node*)malloc(sizeof(Node));
 
    // put in the data
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return newNode;
}
 
// function to count subtress that
// sum up to a given value x
int countSubtreesWithSumX(Node* root,
                          int& count, int x)
{
    // if tree is empty
    if (!root)
        return 0;
 
    // sum of nodes in the left subtree
    int ls = countSubtreesWithSumX(root->left, count, x);
 
    // sum of nodes in the right subtree
    int rs = countSubtreesWithSumX(root->right, count, x);
 
    // sum of nodes in the subtree rooted
    // with 'root->data'
    int sum = ls + rs + root->data;
 
    // if true
    if (sum == x)
        count++;
 
    // return subtree's nodes sum
    return sum;
}
 
// utility function to count subtress that
// sum up to a given value x
int countSubtreesWithSumXUtil(Node* root, int x)
{
    // if tree is empty
    if (!root)
        return 0;
 
    int count = 0;
 
    // sum of nodes in the left subtree
    int ls = countSubtreesWithSumX(root->left, count, x);
 
    // sum of nodes in the right subtree
    int rs = countSubtreesWithSumX(root->right, count, x);
 
    // if tree's nodes sum == x
    if ((ls + rs + root->data) == x)
        count++;
 
    // required count of subtrees
    return count;
}
 
// Driver program to test above
int main()
{
    /* binary tree creation    
                5
              /   \  
           -10     3
           /  \   /  \
          9    8 -4   7
    */
    Node* root = getNode(5);
    root->left = getNode(-10);
    root->right = getNode(3);
    root->left->left = getNode(9);
    root->left->right = getNode(8);
    root->right->left = getNode(-4);
    root->right->right = getNode(7);
 
    int x = 7;
 
    cout << "Count = "
         << countSubtreesWithSumXUtil(root, x);
 
    return 0;
}

Java

// Java program to find if 
// there is a subtree with 
// given sum 
import java.util.*; 
class GFG
{
 
// structure of a node 
// of binary tree 
static class Node
{ 
    int data; 
    Node left, right; 
}
 
static class INT
{
    int v;
    INT(int a)
    {
        v = a;
    }
}
 
// function to get a new node 
static Node getNode(int data) 
{ 
    // allocate space 
    Node newNode = new Node(); 
 
    // put in the data 
    newNode.data = data; 
    newNode.left = newNode.right = null; 
    return newNode; 
} 
 
// function to count subtress that 
// sum up to a given value x 
static int countSubtreesWithSumX(Node root, 
                          INT count, int x) 
{ 
    // if tree is empty 
    if (root == null) 
        return 0; 
 
    // sum of nodes in the left subtree 
    int ls = countSubtreesWithSumX(root.left, 
                                   count, x); 
 
    // sum of nodes in the right subtree 
    int rs = countSubtreesWithSumX(root.right, 
                                   count, x); 
 
    // sum of nodes in the subtree 
    // rooted with 'root.data' 
    int sum = ls + rs + root.data; 
 
    // if true 
    if (sum == x) 
        count.v++; 
 
    // return subtree's nodes sum 
    return sum; 
} 
 
// utility function to 
// count subtress that 
// sum up to a given value x 
static int countSubtreesWithSumXUtil(Node root, 
                                     int x) 
{ 
    // if tree is empty 
    if (root == null) 
        return 0; 
 
    INT count = new INT(0); 
 
    // sum of nodes in the left subtree 
    int ls = countSubtreesWithSumX(root.left,
                                   count, x); 
 
    // sum of nodes in the right subtree 
    int rs = countSubtreesWithSumX(root.right, 
                                   count, x); 
 
    // if tree's nodes sum == x 
    if ((ls + rs + root.data) == x) 
        count.v++; 
 
    // required count of subtrees 
    return count.v; 
} 
 
// Driver Code
public static void main(String args[])
{ 
    /* binary tree creation     
                5 
            / \ 
        -10     3 
        / \ / \ 
        9 8 -4 7 
    */
    Node root = getNode(5); 
    root.left = getNode(-10); 
    root.right = getNode(3); 
    root.left.left = getNode(9); 
    root.left.right = getNode(8); 
    root.right.left = getNode(-4); 
    root.right.right = getNode(7); 
 
    int x = 7; 
 
    System.out.println("Count = " + 
           countSubtreesWithSumXUtil(root, x)); 
} 
}
 
// This code is contributed 
// by Arnab Kundu

Python3

# Python3 implementation to count subtress 
# that Sum up to a given value x 
 
# class to get a new node 
class getNode:
    def __init__(self, data):
         
        # put in the data 
        self.data = data 
        self.left = self.right = None
         
# function to count subtress that 
# Sum up to a given value x 
def countSubtreesWithSumX(root, count, x):
     
    # if tree is empty 
    if (not root):
        return 0
 
    # Sum of nodes in the left subtree 
    ls = countSubtreesWithSumX(root.left,
                               count, x) 
 
    # Sum of nodes in the right subtree 
    rs = countSubtreesWithSumX(root.right, 
                               count, x) 
 
    # Sum of nodes in the subtree 
    # rooted with 'root.data' 
    Sum = ls + rs + root.data 
 
    # if true 
    if (Sum == x): 
        count[0] += 1
 
    # return subtree's nodes Sum 
    return Sum
 
# utility function to count subtress
# that Sum up to a given value x 
def countSubtreesWithSumXUtil(root, x):
     
    # if tree is empty 
    if (not root):
        return 0
 
    count = [0] 
 
    # Sum of nodes in the left subtree 
    ls = countSubtreesWithSumX(root.left, 
                               count, x) 
 
    # Sum of nodes in the right subtree 
    rs = countSubtreesWithSumX(root.right,
                               count, x) 
 
    # if tree's nodes Sum == x 
    if ((ls + rs + root.data) == x): 
        count[0] += 1
 
    # required count of subtrees 
    return count[0]
 
# Driver Code
if __name__ == '__main__':
     
    # binary tree creation     
    #         5 
    #         / \ 
    #     -10     3 
    #     / \ / \ 
    #     9 8 -4 7 
    root = getNode(5) 
    root.left = getNode(-10) 
    root.right = getNode(3) 
    root.left.left = getNode(9) 
    root.left.right = getNode(8) 
    root.right.left = getNode(-4) 
    root.right.right = getNode(7) 
 
    x = 7
 
    print("Count =",
           countSubtreesWithSumXUtil(root, x))
 
# This code is contributed by PranchalK

C#

using System;
 
// c# program to find if 
// there is a subtree with 
// given sum 
public class GFG
{
 
// structure of a node 
// of binary tree 
public class Node
{
    public int data;
    public Node left, right;
}
 
public class INT
{
    public int v;
    public INT(int a)
    {
        v = a;
    }
}
 
// function to get a new node 
public static Node getNode(int data)
{
    // allocate space 
    Node newNode = new Node();
 
    // put in the data 
    newNode.data = data;
    newNode.left = newNode.right = null;
    return newNode;
}
 
// function to count subtress that 
// sum up to a given value x 
public static int countSubtreesWithSumX(Node root, 
                                    INT count, int x)
{
    // if tree is empty 
    if (root == null)
    {
        return 0;
    }
 
    // sum of nodes in the left subtree 
    int ls = countSubtreesWithSumX(root.left, count, x);
 
    // sum of nodes in the right subtree 
    int rs = countSubtreesWithSumX(root.right, count, x);
 
    // sum of nodes in the subtree 
    // rooted with 'root.data' 
    int sum = ls + rs + root.data;
 
    // if true 
    if (sum == x)
    {
        count.v++;
    }
 
    // return subtree's nodes sum 
    return sum;
}
 
// utility function to 
// count subtress that 
// sum up to a given value x 
public static int countSubtreesWithSumXUtil(Node root, int x)
{
    // if tree is empty 
    if (root == null)
    {
        return 0;
    }
 
    INT count = new INT(0);
 
    // sum of nodes in the left subtree 
    int ls = countSubtreesWithSumX(root.left, count, x);
 
    // sum of nodes in the right subtree 
    int rs = countSubtreesWithSumX(root.right, count, x);
 
    // if tree's nodes sum == x 
    if ((ls + rs + root.data) == x)
    {
        count.v++;
    }
 
    // required count of subtrees 
    return count.v;
}
 
// Driver Code 
public static void Main(string[] args)
{
    /* binary tree creation     
                5 
            / \ 
        -10     3 
        / \ / \ 
        9 8 -4 7 
    */
    Node root = getNode(5);
    root.left = getNode(-10);
    root.right = getNode(3);
    root.left.left = getNode(9);
    root.left.right = getNode(8);
    root.right.left = getNode(-4);
    root.right.right = getNode(7);
 
    int x = 7;
 
    Console.WriteLine("Count = " + countSubtreesWithSumXUtil(root, x));
}
}
 
// This code is contributed by Shrikant13

Output:

Count = 2

Time Complexity: O(n).

Another Approach:

countSubtreesWithSumXUtil(root, x)

 Initialize static count = 0
 Initialize static *ptr = root
    if !root then
        return 0
    
    Initialize static count = 0
    ls+ = countSubtreesWithSumXUtil(root->left, count, x)
    rs+ = countSubtreesWithSumXUtil(root->right, count, x)
    
    if (ls + rs + root->data) == x
        count++
    
    if(ptr!=root)
       return ls + root->data + rs
    else
    return count

C++

// C++ program to find if 
// there is a subtree with 
// given sum 
#include <bits/stdc++.h>
 
using namespace std;
 
// Structure of a node of binary tree
struct Node {
    int data;
    Node *left, *right;
};
 
// Function to get a new node
Node* getNode(int data)
{
    // Allocate space
    Node* newNode = (Node*)malloc(sizeof(Node));
 
    // Put in the data
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return newNode;
}
 
 
 
 
// Utility function to count subtress that
// sum up to a given value x
int countSubtreesWithSumXUtil(Node* root, int x)
{
    static int count=0;
    static Node* ptr=root;
    int l=0,r=0;
    if(root==NULL)
    return 0;
     
    l+=countSubtreesWithSumXUtil(root->left,x);
     
    r+=countSubtreesWithSumXUtil(root->right,x);
 
    if(l+r+root->data==x)
    count++;
 
    if(ptr!=root)
        return l+root->data+r;
     
    return count;
     
         
}
 
// Driver code
int main()
{
    /* binary tree creation 
              5
            /  \ 
          -10   3
          / \  / \
          9 8 -4 7
    */
    Node* root = getNode(5);
    root->left = getNode(-10);
    root->right = getNode(3);
    root->left->left = getNode(9);
    root->left->right = getNode(8);
    root->right->left = getNode(-4);
    root->right->right = getNode(7);
 
    int x = 7;
 
    cout << "Count = "
        << countSubtreesWithSumXUtil(root, x);
 
    return 0;
}
// This code is contributed by Sadik Ali

Java

// Java program to find if 
// there is a subtree with 
// given sum 
import java.io.*;
 
// Node class to create new node
class Node
{
    int data;
    Node left;
    Node right;
    Node(int data)
    {
        this.data = data;
    }
}
 
class GFG
{
    static int count = 0;
    static Node ptr;
     
    // Utility function to count subtress that 
    // sum up to a given value x
    int countSubtreesWithSumXUtil(Node root, int x)
    {
        int l = 0, r = 0;
        if(root == null) return 0;
        l += countSubtreesWithSumXUtil(root.left, x);
        r += countSubtreesWithSumXUtil(root.right, x);
        if(l + r + root.data == x) count++;
        if(ptr != root) return l + root.data + r;
        return count;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        /* binary tree creation 
            5 
        / \ 
        -10 3 
        / \ / \ 
        9 8 -4 7 
        */
        Node root = new Node(5);
        root.left = new Node(-10);
        root.right = new Node(3);
        root.left.left = new Node(9);
        root.left.right = new Node(8);
        root.right.left = new Node(-4);
        root.right.right = new Node(7);
        int x = 7;
        ptr = root; // assigning global value of ptr
        System.out.println("Count = " +
               new GFG().countSubtreesWithSumXUtil(root, x));
    }
}
 
// This code is submitted by Devarshi_Singh

Python3

# Python3 program to find if there is 
# a subtree with given sum 
  
# Structure of a node of binary tree
class Node:
     
    def __init__(self, data):
         
        self.data = data
        self.left = None
        self.right = None
  
# Function to get a new node
def getNode(data):
 
    # Allocate space
    newNode = Node(data)
    return newNode
 
count = 0
ptr = None
 
# Utility function to count subtress that
# sum up to a given value x
def countSubtreesWithSumXUtil(root, x):
     
    global count, ptr
 
    l = 0
    r = 0
     
    if (root == None):
        return 0  
      
    l += countSubtreesWithSumXUtil(root.left, x)
    r += countSubtreesWithSumXUtil(root.right, x)
  
    if (l + r + root.data == x):
        count += 1
  
    if (ptr != root):
        return l + root.data + r
      
    return count
      
# Driver code
if __name__=='__main__':
     
    ''' binary tree creation 
              5
            /  \ 
          -10   3
          / \  / \
          9 8 -4 7
    '''
     
    root = getNode(5)
    root.left = getNode(-10)
    root.right = getNode(3)
    root.left.left = getNode(9)
    root.left.right = getNode(8)
    root.right.left = getNode(-4)
    root.right.right = getNode(7)
  
    x = 7
    ptr = root
     
    print("Count = " + str(countSubtreesWithSumXUtil(
        root, x)))
  
# This code is contributed by pratham76

C#

// C# program to find if 
// there is a subtree with 
// given sum 
using System;
  
// Node class to 
// create new node
public class Node
{
  public int data;
  public Node left;
  public Node right;
  public Node(int data)
  {
    this.data = data;
  }
}
  
class GFG{
 
static int count = 0;
static Node ptr;
 
// Utility function to count subtress 
// that sum up to a given value x
int countSubtreesWithSumXUtil(Node root, 
                              int x)
{
  int l = 0, r = 0;
  if(root == null) return 0;
  l += countSubtreesWithSumXUtil(root.left, x);
  r += countSubtreesWithSumXUtil(root.right, x);
  if(l + r + root.data == x) count++;
  if(ptr != root) return l + root.data + r;
  return count;
}
 
// Driver Code
public static void Main(string[] args)
{
  /* binary tree creation 
            5 
        / \ 
        -10 3 
        / \ / \ 
        9 8 -4 7 
        */
  Node root = new Node(5);
  root.left = new Node(-10);
  root.right = new Node(3);
  root.left.left = new Node(9);
  root.left.right = new Node(8);
  root.right.left = new Node(-4);
  root.right.right = new Node(7);
  int x = 7;
   
  // Assigning global value of ptr
  ptr = root; 
  Console.Write("Count = " + 
          new GFG().countSubtreesWithSumXUtil(root, x));
}
}
 
// This code is contributed by rutvik_56

Output:

Count = 2

Time Complexity: O(n).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Related Articles

C++

Java

Python3

C#

C++

Java

Python3

C#