Convert a given Binary tree to a tree that holds Logical AND property

Given a Binary Tree (Every node has at most 2 children) where each node has value either 0 or 1. Convert a given Binary tree to a tree that holds Logical AND property, i.e., each node value should be the logical AND between its children.

Examples:

```Input : The below tree doesn’t hold the logical AND property
convert it to a tree that holds the property.
1
/
1     0
/    /
0   1 1   1
Output :
0
/
0     1
/    /
0   1 1   1
```

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to traverse given binary tree in postorder fashion. For each node check (recursively) if the node has one children then we don’t have any need to check else if the node has both its child then simply update the node data with the logical AND of its child data.

C++

 `// C++ code to covert a given binary tree ` `// to a tree that holds logical AND property. ` `#include ` `using` `namespace` `std; ` ` `  `// Structure of binary tree ` `struct` `Node ` `{ ` `    ``int` `data; ` `    ``struct` `Node* left; ` `    ``struct` `Node* right; ` `}; ` ` `  `// function to create a new node ` `struct` `Node* newNode(``int` `key) ` `{ ` `    ``struct` `Node* node = ``new` `Node; ` `    ``node->data= key; ` `    ``node->left = node->right = NULL; ` `    ``return` `node; ` `} ` ` `  `// Convert the given tree to a tree where ` `// each node is logical AND of its children ` `// The main idea is to do Postorder traversal ` `void` `convertTree(Node *root) ` `{ ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``/* first recur on left child */` `    ``convertTree(root->left); ` ` `  `    ``/* then recur on right child */` `    ``convertTree(root->right); ` ` `  `    ``if` `(root->left != NULL && root->right != NULL) ` `        ``root->data = (root->left->data) & ` `                     ``(root->right->data); ` `} ` ` `  `void` `printInorder(Node* root) ` `{ ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``/* first recur on left child */` `    ``printInorder(root->left); ` ` `  `    ``/* then print the data of node */` `    ``printf``(``"%d "``, root->data); ` ` `  `    ``/* now recur on right child */` `    ``printInorder(root->right); ` `} ` ` `  `// main function ` `int` `main() ` `{ ` `    ``/* Create following Binary Tree ` `             ``1 ` `           ``/   ` `          ``1     0 ` `         ``/    / ` `        ``0   1 1   1 ` `             ``*/` ` `  `    ``Node *root=newNode(0); ` `    ``root->left=newNode(1); ` `    ``root->right=newNode(0); ` `    ``root->left->left=newNode(0); ` `    ``root->left->right=newNode(1); ` `    ``root->right->left=newNode(1); ` `    ``root->right->right=newNode(1); ` `    ``printf``(````" Inorder traversal before conversion "````); ` `    ``printInorder(root); ` ` `  `    ``convertTree(root); ` ` `  `    ``printf``(````" Inorder traversal after conversion "````); ` `    ``printInorder(root); ` `    ``return` `0; ` `} `

Java

 `// Java code to covert a given binary tree  ` `// to a tree that holds logical AND property.  ` `class` `GfG {  ` ` `  `// Structure of binary tree  ` `static` `class` `Node  ` `{  ` `    ``int` `data;  ` `     ``Node left;  ` `     ``Node right;  ` `}  ` ` `  `// function to create a new node  ` `static` `Node newNode(``int` `key)  ` `{  ` `    ``Node node = ``new` `Node();  ` `    ``node.data= key;  ` `    ``node.left = ``null``; ` `    ``node.right = ``null``;  ` `    ``return` `node;  ` `}  ` ` `  `// Convert the given tree to a tree where  ` `// each node is logical AND of its children  ` `// The main idea is to do Postorder traversal  ` `static` `void` `convertTree(Node root)  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``/* first recur on left child */` `    ``convertTree(root.left);  ` ` `  `    ``/* then recur on right child */` `    ``convertTree(root.right);  ` ` `  `    ``if` `(root.left != ``null` `&& root.right != ``null``)  ` `        ``root.data = (root.left.data) & (root.right.data);  ` `}  ` ` `  `static` `void` `printInorder(Node root)  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``/* first recur on left child */` `    ``printInorder(root.left);  ` ` `  `    ``/* then print the data of node */` `    ``System.out.print(root.data + ``" "``);  ` ` `  `    ``/* now recur on right child */` `    ``printInorder(root.right);  ` `}  ` ` `  `// main function  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``/* Create following Binary Tree  ` `            ``1  ` `        ``/   ` `        ``1     0  ` `        ``/ /   ` `        ``0 1 1 1  ` `            ``*/` ` `  `    ``Node root=newNode(``0``);  ` `    ``root.left=newNode(``1``);  ` `    ``root.right=newNode(``0``);  ` `    ``root.left.left=newNode(``0``);  ` `    ``root.left.right=newNode(``1``);  ` `    ``root.right.left=newNode(``1``);  ` `    ``root.right.right=newNode(``1``);  ` `    ``System.out.print(``"Inorder traversal before conversion "``);  ` `    ``printInorder(root);  ` ` `  `    ``convertTree(root);  ` `    ``System.out.println(); ` `    ``System.out.print(``"Inorder traversal after conversion "``);  ` `    ``printInorder(root);  ` `}}  `

Python3

 `# Program to convert an aribitary binary tree  ` `# to a tree that holds children sum property  ` ` `  `# Helper function that allocates a new  ` `# node with the given data and None  ` `# left and right poers.                                      ` `class` `newNode:  ` ` `  `    ``# Construct to create a new node  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.data ``=` `key ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Convert the given tree to a tree where  ` `# each node is logical AND of its children  ` `# The main idea is to do Postorder traversal  ` `def` `convertTree(root) : ` ` `  `    ``if` `(root ``=``=` `None``) : ` `        ``return` ` `  `    ``""" first recur on left child """` `    ``convertTree(root.left)  ` ` `  `    ``""" then recur on right child """` `    ``convertTree(root.right)  ` ` `  `    ``if` `(root.left !``=` `None` `and` `root.right !``=` `None``):  ` `        ``root.data ``=` `((root.left.data) &  ` `                     ``(root.right.data))  ` ` `  `def` `printInorder(root) : ` ` `  `    ``if` `(root ``=``=` `None``) : ` `        ``return` ` `  `    ``""" first recur on left child """` `    ``printInorder(root.left)  ` ` `  `    ``""" then print the data of node """` `    ``print``( root.data, end ``=` `" "``)  ` ` `  `    ``""" now recur on right child """` `    ``printInorder(root.right)  ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``""" Create following Binary Tree  ` `            ``1  ` `        ``/   ` `        ``1     0  ` `        ``/ /   ` `        ``0 1 1 1  ` `            ``"""` ` `  `    ``root ``=` `newNode(``0``)  ` `    ``root.left ``=` `newNode(``1``)  ` `    ``root.right ``=` `newNode(``0``)  ` `    ``root.left.left ``=` `newNode(``0``)  ` `    ``root.left.right ``=` `newNode(``1``)  ` `    ``root.right.left ``=` `newNode(``1``)  ` `    ``root.right.right ``=` `newNode(``1``) ` ` `  `    ``print``(``"Inorder traversal before conversion"``,  ` `                                      ``end ``=` `" "``) ` `    ``printInorder(root) ` ` `  `    ``convertTree(root) ` ` `  `    ``print``(````" Inorder traversal after conversion "````, ` `                                        ``end ``=` `" "``) ` `    ``printInorder(root) ` ` `  `# This code is contributed by ` `# Shubham Singh(SHUBHAMSINGH10) `

C#

 `// C# code to covert a given binary tree  ` `// to a tree that holds logical AND property. ` `using` `System; ` ` `  `class` `GfG  ` `{  ` ` `  `// Structure of binary tree  ` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left;  ` `    ``public` `Node right;  ` `}  ` ` `  `// function to create a new node  ` `static` `Node newNode(``int` `key)  ` `{  ` `    ``Node node = ``new` `Node();  ` `    ``node.data= key;  ` `    ``node.left = ``null``;  ` `    ``node.right = ``null``;  ` `    ``return` `node;  ` `}  ` ` `  `// Convert the given tree to a tree where  ` `// each node is logical AND of its children  ` `// The main idea is to do Postorder traversal  ` `static` `void` `convertTree(Node root)  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``/* first recur on left child */` `    ``convertTree(root.left);  ` ` `  `    ``/* then recur on right child */` `    ``convertTree(root.right);  ` ` `  `    ``if` `(root.left != ``null` `&& root.right != ``null``)  ` `        ``root.data = (root.left.data) & (root.right.data);  ` `}  ` ` `  `static` `void` `printInorder(Node root)  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``/* first recur on left child */` `    ``printInorder(root.left);  ` ` `  `    ``/* then print the data of node */` `    ``Console.Write(root.data + ``" "``);  ` ` `  `    ``/* now recur on right child */` `    ``printInorder(root.right);  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `Main()  ` `{  ` `    ``/* Create following Binary Tree  ` `            ``1  ` `        ``/   ` `        ``1 0  ` `        ``/ /   ` `        ``0 1 1 1  ` `            ``*/` ` `  `    ``Node root=newNode(0);  ` `    ``root.left=newNode(1);  ` `    ``root.right=newNode(0);  ` `    ``root.left.left=newNode(0);  ` `    ``root.left.right=newNode(1);  ` `    ``root.right.left=newNode(1);  ` `    ``root.right.right=newNode(1);  ` `    ``Console.Write(``"Inorder traversal before conversion "``);  ` `    ``printInorder(root);  ` ` `  `    ``convertTree(root);  ` `    ``Console.WriteLine(); ` `    ``Console.Write(``"Inorder traversal after conversion "``);  ` `    ``printInorder(root);  ` `} ` `}  ` ` `  `/* This code is contributed by Rajput-Ji*/`

Output:

``` Inorder traversal before conversion 0 1 1 0 1 0 1
Inorder traversal after conversion 0 0 1 0 1 1 1
```

Tree Tree