Count subtrees that sum up to a given value x only using single recursive function
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.