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
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.
Implementation:
C++
// C++ code to convert a given binary tree// to a tree that holds logical AND property.#include<bits/stdc++.h>using namespace std;// Structure of binary treestruct Node{ int data; struct Node* left; struct Node* right;};// function to create a new nodestruct 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 traversalvoid 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 functionint 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("\n Inorder traversal before conversion "); printInorder(root); convertTree(root); printf("\n Inorder traversal after conversion "); printInorder(root); return 0;} |
Java
// Java code to convert 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 arbitrary 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 pointers. 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("\nInorder traversal after conversion ", end = " ") printInorder(root)# This code is contributed by# Shubham Singh(SHUBHAMSINGH10) |
C#
// 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); } 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 codepublic 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*/ |
Javascript
<script> // Javascript code to convert a given binary tree // to a tree that holds logical AND property.// Structure of binary tree class Node { constructor() { this.data = 0; this.left = null; this.right = null; } } // Function to create a new node function newNode(key) { var 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 function convertTree(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 printInorder(root) { if (root == null) return; /* First recur on left child */ printInorder(root.left); /* then print the data of node */ document.write(root.data + " "); /* Now recur on right child */ printInorder(root.right); } // Driver code/* Create following Binary Tree 1 / \ 1 0 / \ / \ 0 1 1 1 */var 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); document.write("Inorder traversal before conversion "); printInorder(root); convertTree(root); document.write("<br>");document.write("Inorder traversal after conversion "); printInorder(root); // This code is contributed by noob2000</script> |
Output
Inorder traversal before conversion 0 1 1 0 1 0 1 Inorder traversal after conversion 0 0 1 0 1 1 1
Time Complexity: O(n)
Space Complexity: O(n) n is the recursive stack space.
This article is contributed by Roshni Agarwal. If you like neveropen and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the neveropen main page and help other Geeks.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
