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
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++
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int data;
struct Node* left;
struct Node* right;
};
struct Node* newNode( int key)
{
struct Node* node = new Node;
node->data= key;
node->left = node->right = NULL;
return node;
}
void convertTree(Node *root)
{
if (root == NULL)
return ;
convertTree(root->left);
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 ;
printInorder(root->left);
printf ( "%d " , root->data);
printInorder(root->right);
}
int 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);
printf ( "\n Inorder traversal before conversion " );
printInorder(root);
convertTree(root);
printf ( "\n Inorder traversal after conversion " );
printInorder(root);
return 0;
}
|
Java
class GfG {
static class Node
{
int data;
Node left;
Node right;
}
static Node newNode( int key)
{
Node node = new Node();
node.data= key;
node.left = null ;
node.right = null ;
return node;
}
static void convertTree(Node root)
{
if (root == null )
return ;
convertTree(root.left);
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 ;
printInorder(root.left);
System.out.print(root.data + " " );
printInorder(root.right);
}
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 );
System.out.print( "Inorder traversal before conversion " );
printInorder(root);
convertTree(root);
System.out.println();
System.out.print( "Inorder traversal after conversion " );
printInorder(root);
}}
|
Python3
class newNode:
def __init__( self , key):
self .data = key
self .left = None
self .right = None
def convertTree(root) :
if (root = = None ) :
return
convertTree(root.left)
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
printInorder(root.left)
print ( root.data, end = " " )
printInorder(root.right)
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 )
print ( "Inorder traversal before conversion" ,
end = " " )
printInorder(root)
convertTree(root)
print ( "\nInorder traversal after conversion " ,
end = " " )
printInorder(root)
|
C#
using System;
class GfG
{
class Node
{
public int data;
public Node left;
public Node right;
}
static Node newNode( int key)
{
Node node = new Node();
node.data= key;
node.left = null ;
node.right = null ;
return node;
}
static void convertTree(Node root)
{
if (root == null )
return ;
convertTree(root.left);
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 ;
printInorder(root.left);
Console.Write(root.data + " " );
printInorder(root.right);
}
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);
Console.Write( "Inorder traversal before conversion " );
printInorder(root);
convertTree(root);
Console.WriteLine();
Console.Write( "Inorder traversal after conversion " );
printInorder(root);
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
}
function newNode(key)
{
var node = new Node();
node.data = key;
node.left = null ;
node.right = null ;
return node;
}
function convertTree(root)
{
if (root == null )
return ;
convertTree(root.left);
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 ;
printInorder(root.left);
document.write(root.data + " " );
printInorder(root.right);
}
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);
</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.
Last Updated :
20 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...