# Largest sub-tree having equal no of 1’s and 0’s

• Difficulty Level : Medium
• Last Updated : 12 Apr, 2022

Given a tree having every node’s value as either 0 or 1, the task is to find the maximum size of the sub-tree in the given tree that has equal number of 0’s and 1’s, if no such sub-tree exists then print -1.
Examples:

Input:

Output: 6
Input:

Output: -1

Approach:

1. Change all the nodes of the tree which are 0 to -1. Now the problem gets reduced to finding the maximum size of a sub-tree sum of whose nodes is 0.
2. Update all the nodes of the tree so that they represent the sum of all nodes in the sub-tree rooted at the current node.
3. Now find the size of the maximum sub-tree rooted at a node whose value is 0. If no such node is found then print -1

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// To store the size of the maximum sub-tree``// with equal number of 0's and 1's``int` `maxSize = -1;` `// Represents a node of the tree``struct` `node {``    ``int` `data;``    ``struct` `node *right, *left;``};` `// 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 perform inorder traversal on``// the tree and print the nodes in that order``void` `inorder(``struct` `node* root)``{``    ``if` `(root == NULL)``        ``return``;``    ``inorder(root->left);``    ``cout << root->data << endl;``    ``inorder(root->right);``}` `// Function to return the maximum size of``// the sub-tree having equal number of 0's and 1's``int` `maxsize(``struct` `node* root)``{``    ``int` `a = 0, b = 0;``    ``if` `(root == NULL)``        ``return` `0;` `    ``// Max size in the right sub-tree``    ``a = maxsize(root->right);` `    ``// 1 is added for the parent``    ``a = a + 1;` `    ``// Max size in the left sub-tree``    ``b = maxsize(root->left);` `    ``// Total size of the tree``    ``// rooted at the current node``    ``a = b + a;` `    ``// If the current tree has equal``    ``// number of 0's and 1's``    ``if` `(root->data == 0)` `        ``// If the total size exceeds``        ``// the current max``        ``if` `(a >= maxSize)``            ``maxSize = a;` `    ``return` `a;``}` `// Function to update and return the sum``// of all the tree nodes rooted at``// the passed node``int` `sum_tree(``struct` `node* root)``{` `    ``if` `(root != NULL)` `        ``// If current node's value is 0``        ``// then update it to -1``        ``if` `(root->data == 0)``            ``root->data = -1;` `    ``int` `a = 0, b = 0;` `    ``// If left child exists``    ``if` `(root->left != NULL)``        ``a = sum_tree(root->left);` `    ``// If right child exists``    ``if` `(root->right != NULL)``        ``b = sum_tree(root->right);``    ``root->data += (a + b);` `    ``return` `root->data;``}` `// Driver code``int` `main()``{``    ``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);` `    ``sum_tree(root);` `    ``maxsize(root);` `    ``cout << maxSize;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `// To store the size of the maximum sub-tree``// with equal number of 0's and 1's``static` `int` `maxSize = -``1``;` `// Represents a node of the tree``static` `class` `node``{``    ``int` `data;``    ``node right, left;``};` `// 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 perform inorder traversal on``// the tree and print the nodes in that order``static` `void` `inorder(node root)``{``    ``if` `(root == ``null``)``        ``return``;``    ``inorder(root.left);``    ``System.out.print(root.data +``"\n"``);``    ``inorder(root.right);``}` `// Function to return the maximum size of``// the sub-tree having equal number of 0's and 1's``static` `int` `maxsize(node root)``{``    ``int` `a = ``0``, b = ``0``;``    ``if` `(root == ``null``)``        ``return` `0``;` `    ``// Max size in the right sub-tree``    ``a = maxsize(root.right);` `    ``// 1 is added for the parent``    ``a = a + ``1``;` `    ``// Max size in the left sub-tree``    ``b = maxsize(root.left);` `    ``// Total size of the tree``    ``// rooted at the current node``    ``a = b + a;` `    ``// If the current tree has equal``    ``// number of 0's and 1's``    ``if` `(root.data == ``0``)` `        ``// If the total size exceeds``        ``// the current max``        ``if` `(a >= maxSize)``            ``maxSize = a;` `    ``return` `a;``}` `// Function to update and return the sum``// of all the tree nodes rooted at``// the passed node``static` `int` `sum_tree(node root)``{` `    ``if` `(root != ``null``)` `        ``// If current node's value is 0``        ``// then update it to -1``        ``if` `(root.data == ``0``)``            ``root.data = -``1``;` `    ``int` `a = ``0``, b = ``0``;` `    ``// If left child exists``    ``if` `(root.left != ``null``)``        ``a = sum_tree(root.left);` `    ``// If right child exists``    ``if` `(root.right != ``null``)``        ``b = sum_tree(root.right);``    ``root.data += (a + b);` `    ``return` `root.data;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``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``);` `    ``sum_tree(root);` `    ``maxsize(root);` `    ``System.out.print(maxSize);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python implementation of the approach   ``# To store the size of the maximum sub-tree``# with equal number of 0's and 1's``maxSize ``=` `-``1` `# Represents a node of the tree``class` `Node:``    ``def` `__init__(``self``, val ``=` `0``):``        ``self``.data ``=` `val``        ``self``.left ``=` `None``        ``self``.right ``=` `None`` ` `# To create a new node``def` `newnode(key):``    ``temp ``=` `Node()``    ``temp.data ``=` `key``    ``temp.right ``=` `None``    ``temp.left ``=` `None``    ``return` `temp` `# Function to perform inorder traversal on``# the tree and print the nodes in that order``def` `inorder( root):``    ``if` `(root ``=``=` `None``):``        ``return``    ``inorder(root.left)``    ``print``(root.data)``    ``inorder(root.right)` `# Function to return the maximum size of``# the sub-tree having equal number of 0's and 1's``def` `maxsize(root):` `    ``global` `maxSize``    ``a,b ``=` `0``,``0``    ``if` `(root ``=``=` `None``):``        ``return` `0` `    ``# Max size in the right sub-tree``    ``a ``=` `maxsize(root.right)` `    ``# 1 is added for the parent``    ``a ``=` `a ``+` `1` `    ``# Max size in the left sub-tree``    ``b ``=` `maxsize(root.left)` `    ``# Total size of the tree``    ``# rooted at the current node``    ``a ``=` `b ``+` `a` `    ``# If the current tree has equal``    ``# number of 0's and 1's``    ``if` `(root.data ``=``=` `0``):` `        ``# If the total size exceeds``        ``# the current max``        ``if` `(a >``=` `maxSize):``            ``maxSize ``=` `a` `    ``return` `a` `# Function to update and return the sum``# of all the tree nodes rooted at``# the passed node``def` `sum_tree(root):` `    ``if` `(root !``=` `None``):` `        ``# If current node's value is 0``        ``# then update it to -1``        ``if` `(root.data ``=``=` `0``):``            ``root.data ``=` `-``1` `    ``a,b ``=` `0``,``0` `    ``# If left child exists``    ``if` `(root.left !``=` `None``):``        ``a ``=` `sum_tree(root.left)` `    ``# If right child exists``    ``if` `(root.right !``=` `None``):``        ``b ``=` `sum_tree(root.right)``    ``root.data ``+``=` `(a ``+` `b)` `    ``return` `root.data` `# Driver code` `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``)` `sum_tree(root)` `maxsize(root)` `print``(maxSize)` `# This code is contributed by shinjanpatra`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `// To store the size of the maximum sub-tree``// with equal number of 0's and 1's``static` `int` `maxSize = -1;` `// Represents a node of the tree``public` `class` `node``{``    ``public` `int` `data;``    ``public` `node right, left;``};` `// 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 perform inorder traversal on``// the tree and print the nodes in that order``static` `void` `inorder(node root)``{``    ``if` `(root == ``null``)``        ``return``;``    ``inorder(root.left);``    ``Console.Write(root.data +``"\n"``);``    ``inorder(root.right);``}` `// Function to return the maximum size of``// the sub-tree having equal number of 0's and 1's``static` `int` `maxsize(node root)``{``    ``int` `a = 0, b = 0;``    ``if` `(root == ``null``)``        ``return` `0;` `    ``// Max size in the right sub-tree``    ``a = maxsize(root.right);` `    ``// 1 is added for the parent``    ``a = a + 1;` `    ``// Max size in the left sub-tree``    ``b = maxsize(root.left);` `    ``// Total size of the tree``    ``// rooted at the current node``    ``a = b + a;` `    ``// If the current tree has equal``    ``// number of 0's and 1's``    ``if` `(root.data == 0)` `        ``// If the total size exceeds``        ``// the current max``        ``if` `(a >= maxSize)``            ``maxSize = a;` `    ``return` `a;``}` `// Function to update and return the sum``// of all the tree nodes rooted at``// the passed node``static` `int` `sum_tree(node root)``{` `    ``if` `(root != ``null``)` `        ``// If current node's value is 0``        ``// then update it to -1``        ``if` `(root.data == 0)``            ``root.data = -1;` `    ``int` `a = 0, b = 0;` `    ``// If left child exists``    ``if` `(root.left != ``null``)``        ``a = sum_tree(root.left);` `    ``// If right child exists``    ``if` `(root.right != ``null``)``        ``b = sum_tree(root.right);``    ``root.data += (a + b);` `    ``return` `root.data;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``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);` `    ``sum_tree(root);` `    ``maxsize(root);` `    ``Console.Write(maxSize);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`6`

My Personal Notes arrow_drop_up