Skip to content
Related Articles

Related Articles

Improve Article
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 <bits/stdc++.h>
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



<script>
 
// Javascript program to check if there exist a
// subtree with equal number of 1's and 0's
class Node
{
    constructor(key)
    {
        this.data = key;
        this.left = null;
        this.right = null;
    }
}
     
// Function to convert all 0's in the
// tree to -1
function convert(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
function sum_tree(root)
{
    let 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
function checkSubtree(root, 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
 
// Create the Binary Tree
let root = new Node(1);
root.right = new Node(0);
root.right.right = new Node(1);
root.right.right.right = new Node(1);
root.left = new Node(0);
root.left.left = new Node(1);
root.left.left.left = new Node(1);
root.left.right = new Node(0);
root.left.right.left = new Node(1);
root.left.right.left.left = new Node(1);
root.left.right.right = new Node(0);
root.left.right.right.left = new Node(0);
root.left.right.right.left.left = new 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
let d = 0;
if (checkSubtree(root, d) >= 1)
{
    document.write("True<br>");
}
else
{
    document.write("False<br>");
}
 
// This code is contributed by unknown2108
 
</script>
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
Previous
Check if the given binary tree has a sub-tree with equal no of 1's and 0's | Set 2
Next

Print the longest leaf to leaf path in a Binary tree
Recommended Articles
Page :
Check if a binary tree is subtree of another binary tree | Set 2
26, Jul 14
Check if a binary tree is subtree of another binary tree using preorder traversal : Iterative
08, Apr 20
Check if a binary tree is subtree of another binary tree | Set 1
15, Aug 11
Find the largest Complete Subtree in a given Binary Tree
02, May 19
Find the largest Perfect Subtree in a given Binary Tree
01, May 19
Most Frequent Subtree Sum from a given Binary Tree
07, Jan 21
Sum of subtree depths for every node of a given Binary Tree
22, Jan 21
Print all nodes present in the subtree of a given node of a Binary Tree
08, Feb 21
Find the largest BST subtree in a given Binary Tree | Set 1
17, Feb 12
Subtree with given sum in a Binary Tree
23, Dec 16
Maximum average of subtree values in a given Binary Tree
25, Dec 20
Change a Binary Tree so that every node stores sum of all nodes in left subtree
11, Aug 15
Convert a Binary Tree such that every node stores the sum of all nodes in its right subtree
20, Jun 18
Duplicate subtree in Binary Tree | SET 2
30, Aug 19
Check if the given binary tree has a sub-tree with equal no of 1's and 0's | Set 2
15, Mar 19
Largest subtree sum for each vertex of given N-ary Tree
29, Oct 20
Find GCD of each subtree of a given node in an N-ary Tree for Q queries
09, Jun 20
Find the Kth node in the DFS traversal of a given subtree in a Tree
03, Apr 19
Queries to calculate Bitwise OR of each subtree of a given node in an N-ary Tree
08, Dec 20
Count of distinct colors in a subtree of a Colored Tree with given min frequency for Q queries
03, Jun 20
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
19, Jan 18
Check whether a given binary tree is skewed binary tree or not?
18, Nov 18
Check if max sum level of Binary tree divides tree into two equal sum halves
14, Jun 20
Even size subtree in n-ary tree
01, Mar 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
vabzcode12
@vabzcode12
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox