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++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node *left, *right;
};
Node* getNode( int data)
{
Node* newNode = (Node*) malloc ( sizeof (Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
int countSubtreesWithSumX(Node* root,
int & count, int x)
{
if (!root)
return 0;
int ls = countSubtreesWithSumX(root->left, count, x);
int rs = countSubtreesWithSumX(root->right, count, x);
int sum = ls + rs + root->data;
if (sum == x)
count++;
return sum;
}
int countSubtreesWithSumXUtil(Node* root, int x)
{
if (!root)
return 0;
int count = 0;
int ls = countSubtreesWithSumX(root->left, count, x);
int rs = countSubtreesWithSumX(root->right, count, x);
if ((ls + rs + root->data) == x)
count++;
return count;
}
int main()
{
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
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
}
static class INT
{
int v;
INT( int a)
{
v = a;
}
}
static Node getNode( int data)
{
Node newNode = new Node();
newNode.data = data;
newNode.left = newNode.right = null ;
return newNode;
}
static int countSubtreesWithSumX(Node root,
INT count, int x)
{
if (root == null )
return 0 ;
int ls = countSubtreesWithSumX(root.left,
count, x);
int rs = countSubtreesWithSumX(root.right,
count, x);
int sum = ls + rs + root.data;
if (sum == x)
count.v++;
return sum;
}
static int countSubtreesWithSumXUtil(Node root,
int x)
{
if (root == null )
return 0 ;
INT count = new INT( 0 );
int ls = countSubtreesWithSumX(root.left,
count, x);
int rs = countSubtreesWithSumX(root.right,
count, x);
if ((ls + rs + root.data) == x)
count.v++;
return count.v;
}
public static void main(String args[])
{
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));
}
}
|
Python3
class getNode:
def __init__( self , data):
self .data = data
self .left = self .right = None
def countSubtreesWithSumX(root, count, x):
if ( not root):
return 0
ls = countSubtreesWithSumX(root.left,
count, x)
rs = countSubtreesWithSumX(root.right,
count, x)
Sum = ls + rs + root.data
if ( Sum = = x):
count[ 0 ] + = 1
return Sum
def countSubtreesWithSumXUtil(root, x):
if ( not root):
return 0
count = [ 0 ]
ls = countSubtreesWithSumX(root.left,
count, x)
rs = countSubtreesWithSumX(root.right,
count, x)
if ((ls + rs + root.data) = = x):
count[ 0 ] + = 1
return count[ 0 ]
if __name__ = = '__main__' :
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))
|
C#
using System;
public class GFG
{
public class Node
{
public int data;
public Node left, right;
}
public class INT
{
public int v;
public INT( int a)
{
v = a;
}
}
public static Node getNode( int data)
{
Node newNode = new Node();
newNode.data = data;
newNode.left = newNode.right = null ;
return newNode;
}
public static int countSubtreesWithSumX(Node root,
INT count, int x)
{
if (root == null )
{
return 0;
}
int ls = countSubtreesWithSumX(root.left, count, x);
int rs = countSubtreesWithSumX(root.right, count, x);
int sum = ls + rs + root.data;
if (sum == x)
{
count.v++;
}
return sum;
}
public static int countSubtreesWithSumXUtil(Node root, int x)
{
if (root == null )
{
return 0;
}
INT count = new INT(0);
int ls = countSubtreesWithSumX(root.left, count, x);
int rs = countSubtreesWithSumX(root.right, count, x);
if ((ls + rs + root.data) == x)
{
count.v++;
}
return count.v;
}
public static void Main( string [] args)
{
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));
}
}
|
Javascript
<script>
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
let v;
function getNode(data)
{
let newNode = new Node(data);
return newNode;
}
function countSubtreesWithSumX(root, x)
{
if (root == null )
return 0;
let ls = countSubtreesWithSumX(root.left, x);
let rs = countSubtreesWithSumX(root.right, x);
let sum = ls + rs + root.data;
if (sum == x)
v++;
return sum;
}
function countSubtreesWithSumXUtil(root, x)
{
if (root == null )
return 0;
v = 0;
let ls = countSubtreesWithSumX(root.left, x);
let rs = countSubtreesWithSumX(root.right, x);
if ((ls + rs + root.data) == x)
v++;
return v;
}
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));
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node *left, *right;
};
Node* getNode( int data)
{
Node* newNode = (Node*) malloc ( sizeof (Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
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;
}
int main()
{
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
import java.io.*;
class Node
{
int data;
Node left;
Node right;
Node( int data)
{
this .data = data;
}
}
class GFG
{
static int count = 0 ;
static Node ptr;
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;
}
public static void main(String[] args)
{
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;
System.out.println( "Count = " +
new GFG().countSubtreesWithSumXUtil(root, x));
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def getNode(data):
newNode = Node(data)
return newNode
count = 0
ptr = None
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
if __name__ = = '__main__' :
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)))
|
C#
using System;
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;
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;
}
public static void Main( string [] args)
{
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;
Console.Write( "Count = " +
new GFG().countSubtreesWithSumXUtil(root, x));
}
}
|
Javascript
<script>
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
let count = 0;
let ptr;
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;
}
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;
document.write( "Count = " + countSubtreesWithSumXUtil(root, x));
</script>
|
Output:
Count = 2
Time Complexity: O(n).