Skip to content
Related Articles
Check if the given Binary Tree have a Subtree with equal no of 1’s and 0’s
• Difficulty Level : Hard
• Last Updated : 03 Jun, 2021

Given a Binary Tree having data at nodes as either 0’s or 1’s. The task is to find out whether there exists a subtree having an equal number of 1’s and 0’s.

Examples:

Input Output : True
There are two subtrees present in the above tree where the number of 1’s is equal to the number of 0’s.

Input Output : False
There is no such subtree present which has the number of 1’s equal to number of 0’s

Approach: The idea is to change the data 0’s of the tree to -1. So that it becomes very easy to find the subtree having equal number of 0’s and 1’s. After converting all 0’s to -1, create a sum tree. After creating the sum tree, each node will contain the sum of all node lying under it.

Traverse the tree again and find if there is a node having 0 sum, it means that there is a subtree that has the equal number of 1’s and -1’s, i.e. equal number of 1’s and 0’s.

Below is the implementation of the above approach:

## C++

 `// C++ program to check if there exist a``// subtree with equal number of 1's and 0's` `#include ``using` `namespace` `std;` `// Binary Tree Node``struct` `node {``    ``int` `data;``    ``struct` `node *right, *left;``};` `// Utility function to create a new node``struct` `node* newnode(``int` `key)``{``    ``struct` `node* temp = ``new` `node;``    ``temp->data = key;``    ``temp->right = NULL;``    ``temp->left = NULL;` `    ``return` `temp;``}` `// Function to convert all 0's in the``// tree to -1``void` `convert(``struct` `node* root)``{``    ``if` `(root == NULL) {``        ``return``;``    ``}` `    ``// Move to right subtree``    ``convert(root->right);` `    ``// Replace the 0's with -1 in the tree``    ``if` `(root->data == 0) {``        ``root->data = -1;``    ``}` `    ``// Move to left subtree``    ``convert(root->left);``}` `// Function to convert the tree to a SUM tree``int` `sum_tree(``struct` `node* root)``{``    ``int` `a = 0, b = 0;` `    ``if` `(root == NULL) {``        ``return` `0;``    ``}` `    ``a = sum_tree(root->left);``    ``b = sum_tree(root->right);` `    ``root->data = root->data + a + b;` `    ``return` `root->data;``}` `// Function to check if there exists a subtree``// with equal no of 1s and 0s``int` `checkSubtree(``struct` `node* root, ``int` `d)``{``    ``if` `(root == NULL) {``        ``return` `0;``    ``}` `    ``// Check if there is a subtree with equal``    ``// 1s and 0s or not``    ``if` `(d == 0) {``        ``d = checkSubtree(root->left, d);``    ``}` `    ``if` `(root->data == 0) {``        ``d = 1;``        ``return` `d;``    ``}` `    ``if` `(d == 0) {``        ``d = checkSubtree(root->right, d);``    ``}` `    ``return` `d;``}` `// Driver Code``int` `main()``{``    ``// Create the Binary Tree``    ``struct` `node* root = newnode(1);``    ``root->right = newnode(0);``    ``root->right->right = newnode(1);``    ``root->right->right->right = newnode(1);``    ``root->left = newnode(0);``    ``root->left->left = newnode(1);``    ``root->left->left->left = newnode(1);``    ``root->left->right = newnode(0);``    ``root->left->right->left = newnode(1);``    ``root->left->right->left->left = newnode(1);``    ``root->left->right->right = newnode(0);``    ``root->left->right->right->left = newnode(0);``    ``root->left->right->right->left->left = newnode(1);` `    ``// Convert all 0s in tree to -1``    ``convert(root);` `    ``// Convert the tree into a SUM tree``    ``sum_tree(root);` `    ``// Check if required Subtree exists``    ``int` `d = 0;``    ``if` `(checkSubtree(root, d)) {``        ``cout << ``"True"` `<< endl;``    ``}``    ``else` `{``        ``cout << ``"False"` `<< endl;``    ``}` `    ``return` `0;``}`

## Java

 `// Java program to check if there exist a``// subtree with equal number of 1's and 0's` `import` `java.util.*;``class` `GFG{` `    ``// Binary Tree Node``    ``static` `class` `node {``        ``int` `data;``        ``node right, left;``    ``};``    ` `    ``// Utility function to create a new node``    ``static` `node newnode(``int` `key)``    ``{``        ``node temp = ``new` `node();``        ``temp.data = key;``        ``temp.right = ``null``;``        ``temp.left = ``null``;``    ` `        ``return` `temp;``    ``}``    ` `    ``// Function to convert all 0's in the``    ``// tree to -1``    ``static` `void` `convert(node root)``    ``{``        ``if` `(root == ``null``) {``            ``return``;``        ``}``    ` `        ``// Move to right subtree``        ``convert(root.right);``    ` `        ``// Replace the 0's with -1 in the tree``        ``if` `(root.data == ``0``) {``            ``root.data = -``1``;``        ``}``    ` `        ``// Move to left subtree``        ``convert(root.left);``    ``}``    ` `    ``// Function to convert the tree to a SUM tree``    ``static` `int` `sum_tree(node root)``    ``{``        ``int` `a = ``0``, b = ``0``;``    ` `        ``if` `(root == ``null``) {``            ``return` `0``;``        ``}``    ` `        ``a = sum_tree(root.left);``        ``b = sum_tree(root.right);``    ` `        ``root.data = root.data + a + b;``    ` `        ``return` `root.data;``    ``}``    ` `    ``// Function to check if there exists a subtree``    ``// with equal no of 1s and 0s``    ``static` `int` `checkSubtree(node root, ``int` `d)``    ``{``        ``if` `(root == ``null``) {``            ``return` `0``;``        ``}``    ` `        ``// Check if there is a subtree with equal``        ``// 1s and 0s or not``        ``if` `(d == ``0``) {``            ``d = checkSubtree(root.left, d);``        ``}``    ` `        ``if` `(root.data == ``0``) {``            ``d = ``1``;``            ``return` `d;``        ``}``    ` `        ``if` `(d == ``0``) {``            ``d = checkSubtree(root.right, d);``        ``}``    ` `        ``return` `d;``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``// Create the Binary Tree``        ``node root = newnode(``1``);``        ``root.right = newnode(``0``);``        ``root.right.right = newnode(``1``);``        ``root.right.right.right = newnode(``1``);``        ``root.left = newnode(``0``);``        ``root.left.left = newnode(``1``);``        ``root.left.left.left = newnode(``1``);``        ``root.left.right = newnode(``0``);``        ``root.left.right.left = newnode(``1``);``        ``root.left.right.left.left = newnode(``1``);``        ``root.left.right.right = newnode(``0``);``        ``root.left.right.right.left = newnode(``0``);``        ``root.left.right.right.left.left = newnode(``1``);``    ` `        ``// Convert all 0s in tree to -1``        ``convert(root);``    ` `        ``// Convert the tree into a SUM tree``        ``sum_tree(root);``    ` `        ``// Check if required Subtree exists``        ``int` `d = ``0``;``        ``if` `(checkSubtree(root, d)>=``1``) {``            ``System.out.println(``"True"``);``        ``}``        ``else` `{``            ``System.out.println(``"False"``);``        ``}``    ``}``}`  `// This code is contributed by AbhiThakur`

## Python3

 `# Python3 program to check if there exist a``# subtree with equal number of 1's and 0's` `# Binary Tree Node``class` `node:``    ` `    ``def` `__init__(``self``, key):``        ` `        ``self``.data ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to convert all 0's in the``# tree to -1``def` `convert(root):` `    ``if` `(root ``=``=` `None``):``        ``return` `    ``# Move to right subtree``    ``convert(root.right)` `    ``# Replace the 0's with -1``    ``# in the tree``    ``if` `(root.data ``=``=` `0``):``        ``root.data ``=` `-``1` `    ``# Move to left subtree``    ``convert(root.left)` `# Function to convert the tree``# to a SUM tree``def` `sum_tree(root):``    ` `    ``a ``=` `0``    ``b ``=` `0` `    ``if` `(root ``=``=` `None``):``        ``return` `0` `    ``a ``=` `sum_tree(root.left)``    ``b ``=` `sum_tree(root.right)` `    ``root.data ``=` `root.data ``+` `a ``+` `b` `    ``return` `root.data` `# Function to check if there exists``# a subtree with equal no of 1s and 0s``def` `checkSubtree(root, d):``    ` `    ``if` `(root ``=``=` `None``):``        ``return` `0` `    ``# Check if there is a subtree with``    ``# equal 1s and 0s or not``    ``if` `(d ``=``=` `0``):``        ``d ``=` `checkSubtree(root.left, d)` `    ``if` `(root.data ``=``=` `0``):``        ``d ``=` `1``        ``return` `d` `    ``if` `(d ``=``=` `0``):``        ``d ``=` `checkSubtree(root.right, d)` `    ``return` `d` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Create the Binary Tree``    ``root ``=` `node(``1``)``    ``root.right ``=` `node(``0``)``    ``root.right.right ``=` `node(``1``)``    ``root.right.right.right ``=` `node(``1``)``    ``root.left ``=` `node(``0``)``    ``root.left.left ``=` `node(``1``)``    ``root.left.left.left ``=` `node(``1``)``    ``root.left.right ``=` `node(``0``)``    ``root.left.right.left ``=` `node(``1``)``    ``root.left.right.left.left ``=` `node(``1``)``    ``root.left.right.right ``=` `node(``0``)``    ``root.left.right.right.left ``=` `node(``0``)``    ``root.left.right.right.left.left ``=` `node(``1``)` `    ``# Convert all 0s in tree to -1``    ``convert(root)` `    ``# Convert the tree into a SUM tree``    ``sum_tree(root)` `    ``# Check if required Subtree exists``    ``d ``=` `0``    ` `    ``if` `(checkSubtree(root, d)):``        ``print``(``"True"``)``    ``else``:``        ``print``(``"False"``)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to check if there exist a``// subtree with equal number of 1's and 0's``using` `System;` `class` `GFG{`` ` `    ``// Binary Tree Node``    ``class` `node {``        ``public` `int` `data;``        ``public` `node right, left;``    ``};``     ` `    ``// Utility function to create a new node``    ``static` `node newnode(``int` `key)``    ``{``        ``node temp = ``new` `node();``        ``temp.data = key;``        ``temp.right = ``null``;``        ``temp.left = ``null``;``     ` `        ``return` `temp;``    ``}``     ` `    ``// Function to convert all 0's in the``    ``// tree to -1``    ``static` `void` `convert(node root)``    ``{``        ``if` `(root == ``null``) {``            ``return``;``        ``}``     ` `        ``// Move to right subtree``        ``convert(root.right);``     ` `        ``// Replace the 0's with -1 in the tree``        ``if` `(root.data == 0) {``            ``root.data = -1;``        ``}``     ` `        ``// Move to left subtree``        ``convert(root.left);``    ``}``     ` `    ``// Function to convert the tree to a SUM tree``    ``static` `int` `sum_tree(node root)``    ``{``        ``int` `a = 0, b = 0;``     ` `        ``if` `(root == ``null``) {``            ``return` `0;``        ``}``     ` `        ``a = sum_tree(root.left);``        ``b = sum_tree(root.right);``     ` `        ``root.data = root.data + a + b;``     ` `        ``return` `root.data;``    ``}``     ` `    ``// Function to check if there exists a subtree``    ``// with equal no of 1s and 0s``    ``static` `int` `checkSubtree(node root, ``int` `d)``    ``{``        ``if` `(root == ``null``) {``            ``return` `0;``        ``}``     ` `        ``// Check if there is a subtree with equal``        ``// 1s and 0s or not``        ``if` `(d == 0) {``            ``d = checkSubtree(root.left, d);``        ``}``     ` `        ``if` `(root.data == 0) {``            ``d = 1;``            ``return` `d;``        ``}``     ` `        ``if` `(d == 0) {``            ``d = checkSubtree(root.right, d);``        ``}``     ` `        ``return` `d;``    ``}``     ` `    ``// Driver Code``    ``public` `static` `void` `Main(String []args)``    ``{``        ``// Create the Binary Tree``        ``node root = newnode(1);``        ``root.right = newnode(0);``        ``root.right.right = newnode(1);``        ``root.right.right.right = newnode(1);``        ``root.left = newnode(0);``        ``root.left.left = newnode(1);``        ``root.left.left.left = newnode(1);``        ``root.left.right = newnode(0);``        ``root.left.right.left = newnode(1);``        ``root.left.right.left.left = newnode(1);``        ``root.left.right.right = newnode(0);``        ``root.left.right.right.left = newnode(0);``        ``root.left.right.right.left.left = newnode(1);``     ` `        ``// Convert all 0s in tree to -1``        ``convert(root);``     ` `        ``// Convert the tree into a SUM tree``        ``sum_tree(root);``     ` `        ``// Check if required Subtree exists``        ``int` `d = 0;``        ``if` `(checkSubtree(root, d) >= 1) {``            ``Console.WriteLine(``"True"``);``        ``}``        ``else` `{``            ``Console.WriteLine(``"False"``);``        ``}``    ``}``}` `// This code is contributed by sapnasingh4991`

## Javascript

 ``
Output:
`True`

Time Complexity: O(N)
Space Complexity: O(1)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up