Subtree with given sum in a Binary Tree

Last Updated : 29 Sep, 2024

You are given a binary tree and a given sum. The task is to check if there exists a subtree whose sum of all nodes is equal to the given sum.

Examples:

Input : key = 11

Output: True
Explanation: sum of all nodes of subtree {2, 4, 5} = 11.

Input : key = 6

Output: False
Explanation: No subtree whose sum of all nodes = 6.

Table of Content

[Expected Approach – 1] Using Recursion – O(n) Time and O(h) Space

The idea is to traverse the binary tree recursively, calculating the sum of the subtree rooted at each node. At each node, we compute the sum of its left and right subtrees and add the node’s value itself. If the sum of any subtree matches the given key sum, we mark it as found. We use a helper function subtreeSum() to compute the sum of each subtree and a flag foundSum to track if the key sum is found.

Below is the implementation of the above approach:

C++

// C++ program to find if there is a subtree with // given sum  #include <iostream> using namespace std;  class Node { public:     int data;     Node* left;     Node* right;      Node(int x) {         data = x;         left = nullptr;         right = nullptr;     } };  // Function to calculate the sum of the subtree rooted at the given node int subtreeSum(Node* root, int& foundSum, int target) {        // Base case: If the node is NULL, return 0     if (root == nullptr)         return 0;      // Calculate the sum of the current subtree     int currentSum = root->data +                      subtreeSum(root->left, foundSum, target) +                      subtreeSum(root->right, foundSum, target);      // If the current subtree sum matches the target,      // set foundSum to 1     if (currentSum == target) {         foundSum = 1;     }      // Return the current subtree sum     return currentSum; }  // Function to check if there is a subtree with the given sum bool hasSubtreeWithGivenSum(Node* root, int sum) {     int foundSum = 0;      // Traverse the tree and check for the target sum     subtreeSum(root, foundSum, sum);      // Return true if a subtree with the given sum was found     return foundSum == 1; }  int main() {        // Creating the given binary tree     //        1     //       / \     //      3   6     //     / \   /     //    5   9 8      Node* root = new Node(1);     root->left = new Node(3);     root->right = new Node(6);     root->left->left = new Node(5);     root->left->right = new Node(9);     root->right->left = new Node(8);      if(hasSubtreeWithGivenSum(root, 17)) {       cout << "True";     }   	else cout << "False";     return 0; }

// C program to find if there is a subtree with // given sum  #include <stdio.h> #include <stdlib.h>  struct Node {     int data;     struct Node* left;     struct Node* right; };  // Function to calculate the sum of the subtree rooted at the given node int subtreeSum(struct Node* root, int* foundSum, int target) {        // Base case: If the node is NULL, return 0     if (root == NULL)         return 0;      // Calculate the sum of the current subtree     int currentSum = root->data +                      subtreeSum(root->left, foundSum, target) +                      subtreeSum(root->right, foundSum, target);      // If the current subtree sum matches the target,      // set foundSum to 1     if (currentSum == target) {         *foundSum = 1;     }      // Return the current subtree sum     return currentSum; }  // Function to check if there is a subtree with the given sum int hasSubtreeWithGivenSum(struct Node* root, int sum) {     int foundSum = 0;      // Traverse the tree and check for the target sum     subtreeSum(root, &foundSum, sum);      // Return true if a subtree with the given sum was found     return foundSum == 1; }  struct Node* createNode(int x) {     struct Node* newNode =        (struct Node*)malloc(sizeof(struct Node));     newNode->data = x;     newNode->left = NULL;     newNode->right = NULL;     return newNode; }  int main() {        // Creating the given binary tree     //        1     //       / \     //      3   6     //     / \   /     //    5   9 8      struct Node* root = createNode(1);     root->left = createNode(3);     root->right = createNode(6);     root->left->left = createNode(5);     root->left->right = createNode(9);     root->right->left = createNode(8);           if(hasSubtreeWithGivenSum(root, 17)) {       	printf("True");     }   	else printf("False");      return 0; }

Java

// Java program to find if there is a subtree with // given sum  class Node {     int data;     Node left, right;      Node(int x) {         data = x;         left = right = null;     } }  class GfG {      // Function to calculate the sum of the subtree    	// rooted at the given node     static int subtreeSum(Node root, boolean[] foundSum, int target) {                // Base case: If the node is NULL, return 0         if (root == null)             return 0;          // Calculate the sum of the current subtree         int currentSum = root.data +                          subtreeSum(root.left, foundSum, target) +                          subtreeSum(root.right, foundSum, target);          // If the current subtree sum matches the target,          // set foundSum to true         if (currentSum == target) {             foundSum[0] = true;         }          // Return the current subtree sum         return currentSum;     }      // Function to check if there is a subtree with the given sum     static boolean hasSubtreeWithGivenSum(Node root, int sum) {         boolean[] foundSum = new boolean[1];          // Traverse the tree and check for the target sum         subtreeSum(root, foundSum, sum);          // Return true if a subtree with the given sum was found         return foundSum[0];     }      public static void main(String[] args) {                // Creating the given binary tree         //        1         //       / \         //      3   6         //     / \   /         //    5   9 8          Node root = new Node(1);         root.left = new Node(3);         root.right = new Node(6);         root.left.left = new Node(5);         root.left.right = new Node(9);         root.right.left = new Node(8);          System.out.println(hasSubtreeWithGivenSum(root, 17));     } }

Python

# Python program to find if there is a subtree with # given sum  # Node definition for a binary tree class Node:     def __init__(self, x):         self.data = x         self.left = None         self.right = None  # Function to calculate the sum of the subtree  # rooted at the given node def subtreeSum(root, foundSum, target):        # Base case: If the node is NULL, return 0     if root is None:         return 0      # Calculate the sum of the current subtree     currentSum = (root.data +                   subtreeSum(root.left, foundSum, target) +                   subtreeSum(root.right, foundSum, target))      # If the current subtree sum matches the target,     # set foundSum to True     if currentSum == target:         foundSum[0] = True      # Return the current subtree sum     return currentSum  # Function to check if there is a subtree with the given sum def hasSubtreeWithGivenSum(root, sum):     foundSum = [False]      # Traverse the tree and check for the target sum     subtreeSum(root, foundSum, sum)      # Return true if a subtree with the given sum was found     return foundSum[0]  if __name__ == "__main__":        # Creating the given binary tree     #        1     #       / \     #      3   6     #     / \   /     #    5   9 8      root = Node(1)     root.left = Node(3)     root.right = Node(6)     root.left.left = Node(5)     root.left.right = Node(9)     root.right.left = Node(8)      print(hasSubtreeWithGivenSum(root, 17))

// C# program to find if there is a subtree with // given sum  using System;  class Node {     public int data;     public Node left, right;      public Node(int x) {         data = x;         left = right = null;     } }  class GfG {      // Function to calculate the sum of the subtree    	// rooted at the given node     static int SubtreeSum(Node root, ref bool foundSum, int target) {                // Base case: If the node is NULL, return 0         if (root == null)             return 0;          // Calculate the sum of the current subtree         int currentSum = root.data +                          SubtreeSum(root.left, ref foundSum, target) +                          SubtreeSum(root.right, ref foundSum, target);          // If the current subtree sum matches the target,          // set foundSum to true         if (currentSum == target) {             foundSum = true;         }          // Return the current subtree sum         return currentSum;     }      // Function to check if there is a subtree with the given sum     static bool HasSubtreeWithGivenSum(Node root, int sum) {         bool foundSum = false;          // Traverse the tree and check for the target sum         SubtreeSum(root, ref foundSum, sum);          // Return true if a subtree with the given sum was found         return foundSum;     }      static void Main(string[] args) {                // Creating the given binary tree         //        1         //       / \         //      3   6         //     / \   /         //    5   9 8          Node root = new Node(1);         root.left = new Node(3);         root.right = new Node(6);         root.left.left = new Node(5);         root.left.right = new Node(9);         root.right.left = new Node(8);          Console.WriteLine(HasSubtreeWithGivenSum(root, 17));     } }

JavaScript

// JavaScript program to find if there is a subtree with // given sum  // Node definition for a binary tree class Node {     constructor(x) {         this.data = x;         this.left = null;         this.right = null;     } }  // Function to calculate the sum of the subtree  // rooted at the given node function subtreeSum(root, foundSum, target) {      // Base case: If the node is NULL, return 0     if (root === null)         return 0;      // Calculate the sum of the current subtree     let currentSum = root.data +                      subtreeSum(root.left, foundSum, target) +                      subtreeSum(root.right, foundSum, target);      // If the current subtree sum matches the target,      // set foundSum to true     if (currentSum === target) {         foundSum.value = true;     }      // Return the current subtree sum     return currentSum; }  // Function to check if there is a subtree with the given sum function hasSubtreeWithGivenSum(root, sum) {     let foundSum = { value: false };      // Traverse the tree and check for the target sum     subtreeSum(root, foundSum, sum);      // Return true if a subtree with the given sum was found     return foundSum.value; }  // Creating the given binary tree //        1 //       / \ //      3   6 //     / \   / //    5   9 8  let root = new Node(1); root.left = new Node(3); root.right = new Node(6); root.left.left = new Node(5); root.left.right = new Node(9); root.right.left = new Node(8);  console.log(hasSubtreeWithGivenSum(root, 17));

Output

True

Time Complexity: O(n), As we are visiting every node once.
Auxiliary space: O(h), here h is the height of the tree and the extra space is used due to the recursion call stack.

[Expected Approach – 2] Using HashMap- O(n) Time and O(n) Space

The idea is to use an iterative depth-first traversal of the binary tree while maintaining a running sum of the node values encountered so far. We will use a hashmap to keep track of the prefix sums encountered during the traversal.

Follow the steps below to solve the problem:

Start with the root node of the binary tree and push it onto the stack.
While the stack is not empty, repeatedly:
- Pop the top node from the stack.
- Update the running sum by adding the current node’s value.
- Check if (current sum – target sum) exists in the prefixSumMap. If it does, it means there is a subtree with the required sum.
- Add or update the current running sum in the prefixSumMap to keep track of sums encountered.
- Push the right and left children of the current node onto the stack (if they exist) to continue the traversal.

Below is the implementation of the above approach:

C++

// C++ program to find if there is a subtree with // given sum  #include <bits/stdc++.h> using namespace std;  class Node { public:     int val;     Node* left;     Node* right;      Node(int x) {         val = x;         left = nullptr;         right = nullptr;     } };  // Function to check if there is a subtree with the given sum bool hasSubtreeWithGivenSum(Node* root, int target) {     if (root == nullptr)         return false;      // Map to store the prefix sums     unordered_map<int, int> prefixSumMap;     prefixSumMap[0] = 1;       int sum = 0;       stack<Node*> st;       st.push(root);      // Iterative depth-first traversal     while (!st.empty()) {         Node* curr = st.top();         st.pop();          // Update the running sum with the        	// current node's value         sum += curr->val;          // Check if we have encountered (sum - target) before         if (prefixSumMap.find(sum - target) != prefixSumMap.end()) {             return true;         }          // Add the current running sum to the map         prefixSumMap[sum] = 1;          // Traverse the right and left children         if (curr->right) {             st.push(curr->right);         }         if (curr->left) {             st.push(curr->left);         }     }      // If no subtree with the given sum is found     return false; }  int main() {      // Creating the given binary tree     //        1     //       / \     //      3   6     //     / \   /     //    5   9 8      Node* root = new Node(1);     root->left = new Node(3);     root->right = new Node(6);     root->left->left = new Node(5);     root->left->right = new Node(9);     root->right->left = new Node(8);      if(hasSubtreeWithGivenSum(root, 17)) {       cout << "True";     }   	else cout << "False";      return 0; }

Java

// Java program to find if there is a subtree with // given sum  import java.util.HashMap; import java.util.Stack;  class Node {     int val;     Node left, right;      Node(int x) {         val = x;         left = null;         right = null;     } }  // Function to check if there is a subtree  // with the given sum class GfG {      static boolean hasSubtreeWithGivenSum(Node root, int target) {         if (root == null)             return false;          // Map to store the prefix sums         HashMap<Integer, Integer> prefixSumMap = new HashMap<>();         prefixSumMap.put(0, 1);          int sum = 0;         Stack<Node> st = new Stack<>();         st.push(root);          // Iterative depth-first traversal         while (!st.isEmpty()) {             Node curr = st.pop();              // Update the running sum with the current node's value             sum += curr.val;              // Check if we have encountered (sum - target) before             if (prefixSumMap.containsKey(sum - target)) {                 return true;             }              // Add the current running sum to the map             prefixSumMap.put(sum, 1);              // Traverse the right and left children             if (curr.right != null) {                 st.push(curr.right);             }             if (curr.left != null) {                 st.push(curr.left);             }         }          // If no subtree with the given sum is found         return false;     }      public static void main(String[] args) {          // Creating the given binary tree         //        1         //       / \         //      3   6         //     / \   /         //    5   9 8          Node root = new Node(1);         root.left = new Node(3);         root.right = new Node(6);         root.left.left = new Node(5);         root.left.right = new Node(9);         root.right.left = new Node(8);          System.out.println(hasSubtreeWithGivenSum(root, 17));     } }

Python

# Python program to find if there is a subtree with # given sum  class Node:     def __init__(self, x):         self.val = x         self.left = None         self.right = None  # Function to check if there is a subtree with the given sum def has_subtree_with_given_sum(root, target):     if root is None:         return False      # Map to store the prefix sums     prefix_sum_map = {0: 1}      sum = 0     stack = [root]      # Iterative depth-first traversal     while stack:         curr = stack.pop()          # Update the running sum with the current node's value         sum += curr.val          # Check if we have encountered (sum - target) before         if (sum - target) in prefix_sum_map:             return True          # Add the current running sum to the map         prefix_sum_map[sum] = 1          # Traverse the right and left children         if curr.right:             stack.append(curr.right)         if curr.left:             stack.append(curr.left)      # If no subtree with the given sum is found     return False  # Creating the given binary tree #        1 #       / \ #      3   6 #     / \   / #    5   9 8  root = Node(1) root.left = Node(3) root.right = Node(6) root.left.left = Node(5) root.left.right = Node(9) root.right.left = Node(8)  print(has_subtree_with_given_sum(root, 17))

// C# program to find if there is a subtree with // given sum  using System; using System.Collections.Generic;  class Node {     public int Val;     public Node Left;     public Node Right;      public Node(int x) {         Val = x;         Left = null;         Right = null;     } }  // Function to check if there is a subtree  // with the given sum class GfG {     static bool HasSubtreeWithGivenSum(Node root, int target) {         if (root == null)             return false;          // Map to store the prefix sums         Dictionary<int, int> prefixSumMap = new Dictionary<int, int>();         prefixSumMap[0] = 1;          int sum = 0;         Stack<Node> stack = new Stack<Node>();         stack.Push(root);          // Iterative depth-first traversal         while (stack.Count > 0) {             Node curr = stack.Pop();              // Update the running sum with the current node's value             sum += curr.Val;              // Check if we have encountered (sum - target) before             if (prefixSumMap.ContainsKey(sum - target)) {                 return true;             }              // Add the current running sum to the map             prefixSumMap[sum] = 1;              // Traverse the right and left children             if (curr.Right != null) {                 stack.Push(curr.Right);             }             if (curr.Left != null) {                 stack.Push(curr.Left);             }         }          // If no subtree with the given sum is found         return false;     }      static void Main() {                // Creating the given binary tree         //        1         //       / \         //      3   6         //     / \   /         //    5   9 8          Node root = new Node(1);         root.Left = new Node(3);         root.Right = new Node(6);         root.Left.Left = new Node(5);         root.Left.Right = new Node(9);         root.Right.Left = new Node(8);          Console.WriteLine(HasSubtreeWithGivenSum(root, 17));     } }

JavaScript

// JavaScript program to find if there is a subtree with // given sum  class Node {     constructor(x) {         this.val = x;         this.left = null;         this.right = null;     } }  // Function to check if there is a subtree with the given sum function hasSubtreeWithGivenSum(root, target) {     if (root === null) return false;      // Map to store the prefix sums     const prefixSumMap = new Map();     prefixSumMap.set(0, 1);      let sum = 0;     const stack = [root];      // Iterative depth-first traversal     while (stack.length > 0) {         const curr = stack.pop();          // Update the running sum with the current node's value         sum += curr.val;          // Check if we have encountered (sum - target) before         if (prefixSumMap.has(sum - target)) {             return true;         }          // Add the current running sum to the map         prefixSumMap.set(sum, 1);          // Traverse the right and left children         if (curr.right) {             stack.push(curr.right);         }         if (curr.left) {             stack.push(curr.left);         }     }      // If no subtree with the given sum is found     return false; }  // Creating the given binary tree //        1 //       / \ //      3   6 //     / \   / //    5   9 8  const root = new Node(1); root.left = new Node(3); root.right = new Node(6); root.left.left = new Node(5); root.left.right = new Node(9); root.right.left = new Node(8);  console.log(hasSubtreeWithGivenSum(root, 17));