# Convert a given Binary tree to a tree that holds Logical OR property

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

Example:

```Input:
1
/   \
1      0
/  \    /  \
0    1  1    1

Output: 0 1 1 1 1 1 1
```
```Explanation:
Given Tree
1
/   \
1      0
/  \    /  \
0    1  1    1

After Processing
1
/   \
1      1
/  \    /  \
0    1  1    1
```

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

Approach:
The idea is to traverse given binary tree in postorder fashion because in postorder traversal both the children of the root has already been visited before the root itself.
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 logic OR of its child data.

Below is the implementation of the above approach:

 `// C++ code to convert a ` `// given binary tree to ` `// a tree that holds ` `// logical OR property. ` `#include ` `using` `namespace` `std; ` ` `  `// Structure of the 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 ` `// OR 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 recurr 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() ` `{ ` ` `  `    ``Node* root = newNode(1); ` `    ``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); ` ` `  `    ``convertTree(root); ` `    ``printInorder(root); ` `    ``return` `0; ` `} `

 `# Python program to convert a ` `# given binary tree to ` `# a tree that holds ` `# logical OR property.  ` ` `  `# Function that allocates a new  ` `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 or 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 ``and` `root.right):  ` `        ``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__'``:  ` `     `  `    ``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``)  ` ` `  `    ``convertTree(root)  ` `    ``printInorder(root)  `

 `// Java code to convert a ` `// given binary tree to a ` `// tree that holds logical ` `// OR property. ` `class` `GfG { ` ` `  `    ``// Structure of the 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); ` `    ``} ` ` `  `    ``// Funtion to print inorder traversal ` `    ``// of the tree ` `    ``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); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``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``); ` ` `  `        ``convertTree(root); ` `        ``printInorder(root); ` `    ``} ` `} `

 `// C# code to convert 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); ` `    ``} ` ` `  `    ``// Function to perform the inorder ` `    ``// traversal ` `    ``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() ` `    ``{ ` ` `  `        ``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); ` ` `  `        ``convertTree(root); ` `        ``printInorder(root); ` `    ``} ` `} ` `// This code is contributed by Rajput-Ji `

Output:
```0 1 1 1 1 1 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.

Small things always make you to think big

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : nidhi_biet

Article Tags :
Practice Tags :