Given a binary tree containing n nodes. The problem is to count subtrees having the total node’s data sum equal to a given value using only single recursive functions.
Examples:
Input: X = 7,
5
/ \
-10 3
/ \ / \
9 8 -4 7
Output: 2
Explanation: There are 2 subtrees with sum 7.
1st one is leaf node:
7
2nd one is:
-10
/ \
9 8
Count subtrees that sum up to a given value x using Two Recursive Functions:
The idea is to call recursive function separately for both left and right subtree from the root node.
Follow the steps below to solve the problem:
- Make a call from Util function on to the left and right subtree.
- When the sum of the left subtree and right subtree is calculated then check if the sum of leftSum + rightSum + root = x.
- If the condition is true then increment the count.
- Return this sum to the previous function call.
Pseudocode:
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 sumcountSubtreesWithSumXUtil(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
Below is the implementation of the above approach.
// C++ implementation to count subtrees 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 subtrees 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 subtrees 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 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 subtrees 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 subtrees 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 implementation to count subtrees # 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 subtrees 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 subtrees # 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 |
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 subtrees 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 subtrees 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 |
<script> // Javascript program to find if
// there is a subtree with given sum
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
let v;
// function to get a new node
function getNode(data)
{
// allocate space
let newNode = new Node(data);
return newNode;
}
// function to count subtrees that
// sum up to a given value x
function countSubtreesWithSumX(root, x)
{
// if tree is empty
if (root == null )
return 0;
// sum of nodes in the left subtree
let ls = countSubtreesWithSumX(root.left, x);
// sum of nodes in the right subtree
let rs = countSubtreesWithSumX(root.right, x);
// sum of nodes in the subtree
// rooted with 'root.data'
let sum = ls + rs + root.data;
// if true
if (sum == x)
v++;
// return subtree's nodes sum
return sum;
}
// utility function to
// count subtrees that
// sum up to a given value x
function countSubtreesWithSumXUtil(root, x)
{
// if tree is empty
if (root == null )
return 0;
v = 0;
// sum of nodes in the left subtree
let ls = countSubtreesWithSumX(root.left, x);
// sum of nodes in the right subtree
let rs = countSubtreesWithSumX(root.right, x);
// if tree's nodes sum == x
if ((ls + rs + root.data) == x)
v++;
// required count of subtrees
return v;
}
/* binary tree creation
5
/ \
-10 3
/ \ / \
9 8 -4 7
*/
let 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);
let x = 7;
document.write( "Count = " +
countSubtreesWithSumXUtil(root, x));
// This code is contributed by decode2207. </script> |
Count = 2
Time Complexity: O(N), N nodes are there in the tree and visiting every node once.
Auxiliary Space: O(H), where H is the height of the tree.
Count subtrees that sum up to a given value x using Single Recursive Function:
The idea is same as above approach but instead of using two recursive function we are using one recursive function, to do the same thing we can make count variable static.
Follow the steps below to solve the problem:
- Make a function call from the root node and now explore the right and left subtree from the same function.
- Before that make the count variable static such that it doesn’t get reinitialized again.
- Now, if the function call is at the root node of the tree then return count. Otherwise, return the sum of the subtree.
Pseudocode:
countSubtreesWithSumXUtil(root, x)
Initialize static count = 0
Initialize static *ptr = root
if !root then
return 0Initialize 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
Below is the implementation of the above approach.
// 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 subtrees 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 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 subtrees 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 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 subtrees 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# 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 subtrees
// 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 |
<script> // JavaScript program to find if
// there is a subtree with
// given sum
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
let count = 0;
let ptr;
// Utility function to count subtrees that
// sum up to a given value x
function countSubtreesWithSumXUtil(root, x)
{
let 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;
}
/* binary tree creation
5
/ \
-10 3
/ \ / \
9 8 -4 7
*/
let 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);
let x = 7;
ptr = root; // assigning global value of ptr
document.write( "Count = " + countSubtreesWithSumXUtil(root, x));
</script> |
Count = 2
Time Complexity: O(N), N nodes are there in the tree and visiting every node once.
Auxiliary Space: O(H), where H is the height of the tree.