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 functionx.
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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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++ 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; } // 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 |
chevron_right
filter_none
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
Output:
Count = 2
Time Complexity: O(n).
Recommended Posts:
- Find Count of Single Valued Subtrees
- Number of subtrees having odd count of even numbers
- Count all sub-sequences having product <= K - Recursive approach
- Recursive solution to count substrings with same first and last characters
- Count consonants in a string (Iterative and recursive methods)
- Count full nodes in a Binary tree (Iterative and Recursive)
- Count half nodes in a Binary tree (Iterative and Recursive)
- Function to copy string (Iterative and Recursive)
- Recursive function to delete k-th node from linked list
- Find All Duplicate Subtrees
- Subtrees formed after bursting nodes
- Calculate number of nodes in all subtrees | Using DFS
- Find largest subtree having identical left and right subtrees
- Check if a Binary Tree contains duplicate subtrees of size 2 or more
- Recursive Functions
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.
