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

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/C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ code to convert a
// given binary tree to
// a tree that holds
// logical OR property.
#include <bits/stdc++.h>
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;
}

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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) 

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
    }
}

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

0 1 1 1 1 1 1


My Personal Notes arrow_drop_up

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 :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.