Given a Binary Tree, the task is to check if the binary tree is an Even-Odd binary tree or not.
A Binary Tree is called an Even-Odd Tree when all the nodes which are at even levels have even values (assuming root to be at level 0) and all the nodes which are at odd levels have odd values.
Examples:
Input:
2 / \ 3 9 / \ \ 4 10 6Output: YES
Explanation:
Only node on level 0 (even) is 2 (even).
Nodes present in level 1 are 3 and 9 (both odd).
Nodes present in level 2 are 4, 10 and 6 (all even).
Therefore, the Binary tree is an odd-even binary tree.Input:
4 / \ 3 7 / \ \ 4 10 5Output: NO
Approach: Follow the steps below to solve the problem:
- The idea is to perform level-order traversal and check if the nodes present on even levels are even valued or not and nodes present on odd levels are odd valued or not.
- If any node at an odd level is found to have odd value or vice-versa, then print “NO“.
- Otherwise, after complete traversal of the tree, print “YES“.
Below is the implementation of the above approach:
// C++ program for the above approach #include<bits/stdc++.h> using namespace std;
struct Node
{ int val;
Node *left, *right;
}; struct Node* newNode( int data)
{ struct Node* temp = ( struct Node*) malloc ( sizeof ( struct Node));
temp->val = data;
temp->left = NULL;
temp->right = NULL;
return temp;
} // Function to check if the // tree is even-odd tree bool isEvenOddBinaryTree(Node *root)
{ if (root == NULL)
return true ;
// Stores nodes of each level
queue<Node*> q;
q.push(root);
// Store the current level
// of the binary tree
int level = 0;
// Traverse until the
// queue is empty
while (!q.empty())
{
// Stores the number of nodes
// present in the current level
int size = q.size();
for ( int i = 0; i < size; i++)
{
Node *node = q.front();
// Check if the level
// is even or odd
if (level % 2 == 0)
{
if (node->val % 2 == 1)
return false ;
}
else if (level % 2 == 1)
{
if (node->val % 2 == 0)
return true ;
}
// Add the nodes of the next
// level into the queue
if (node->left != NULL)
{
q.push(node->left);
}
if (node->right != NULL)
{
q.push(node->right);
}
}
// Increment the level count
level++;
}
return true ;
} // Driver Code int main()
{ // Construct a Binary Tree
Node *root = NULL;
root = newNode(2);
root->left = newNode(3);
root->right = newNode(9);
root->left->left = newNode(4);
root->left->right = newNode(10);
root->right->right = newNode(6);
// Check if the binary tree
// is even-odd tree or not
if (isEvenOddBinaryTree(root))
cout << "YES" ;
else
cout << "NO" ;
} // This code is contributed by ipg2016107 |
// Java Program for the above approach import java.util.*;
class GfG {
// Tree node
static class Node {
int val;
Node left, right;
}
// Function to return new tree node
static Node newNode( int data)
{
Node temp = new Node();
temp.val = data;
temp.left = null ;
temp.right = null ;
return temp;
}
// Function to check if the
// tree is even-odd tree
public static boolean
isEvenOddBinaryTree(Node root)
{
if (root == null )
return true ;
// Stores nodes of each level
Queue<Node> q
= new LinkedList<>();
q.add(root);
// Store the current level
// of the binary tree
int level = 0 ;
// Traverse until the
// queue is empty
while (!q.isEmpty()) {
// Stores the number of nodes
// present in the current level
int size = q.size();
for ( int i = 0 ; i < size; i++) {
Node node = q.poll();
// Check if the level
// is even or odd
if (level % 2 == 0 ) {
if (node.val % 2 == 1 )
return false ;
}
else if (level % 2 == 1 ) {
if (node.val % 2 == 0 )
return false ;
}
// Add the nodes of the next
// level into the queue
if (node.left != null ) {
q.add(node.left);
}
if (node.right != null ) {
q.add(node.right);
}
}
// Increment the level count
level++;
}
return true ;
}
// Driver Code
public static void main(String[] args)
{
// Construct a Binary Tree
Node root = null ;
root = newNode( 2 );
root.left = newNode( 3 );
root.right = newNode( 9 );
root.left.left = newNode( 4 );
root.left.right = newNode( 10 );
root.right.right = newNode( 6 );
// Check if the binary tree
// is even-odd tree or not
if (isEvenOddBinaryTree(root)) {
System.out.println( "YES" );
}
else {
System.out.println( "NO" );
}
}
} |
# Python3 program for the above approach # Tree node class Node:
def __init__( self , data):
self .left = None
self .right = None
self .val = data
# Function to return new tree node def newNode(data):
temp = Node(data)
return temp
# Function to check if the # tree is even-odd tree def isEvenOddBinaryTree(root):
if (root = = None ):
return True
q = []
# Stores nodes of each level
q.append(root)
# Store the current level
# of the binary tree
level = 0
# Traverse until the
# queue is empty
while ( len (q) ! = 0 ):
# Stores the number of nodes
# present in the current level
size = len (q)
for i in range (size):
node = q[ 0 ]
q.pop( 0 )
# Check if the level
# is even or odd
if (level % 2 = = 0 ):
if (node.val % 2 = = 1 ):
return False
elif (level % 2 = = 1 ):
if (node.val % 2 = = 0 ):
return False
# Add the nodes of the next
# level into the queue
if (node.left ! = None ):
q.append(node.left)
if (node.right ! = None ):
q.append(node.right)
# Increment the level count
level + = 1
return True
# Driver code if __name__ = = "__main__" :
# Construct a Binary Tree
root = None
root = newNode( 2 )
root.left = newNode( 3 )
root.right = newNode( 9 )
root.left.left = newNode( 4 )
root.left.right = newNode( 10 )
root.right.right = newNode( 6 )
# Check if the binary tree
# is even-odd tree or not
if (isEvenOddBinaryTree(root)):
print ( "YES" )
else :
print ( "NO" )
# This code is contributed by rutvik_56 |
// C# Program for the // above approach using System;
using System.Collections.Generic;
class GfG{
// Tree node class Node
{ public int val;
public Node left, right;
} // Function to return new // tree node static Node newNode( int data)
{ Node temp = new Node();
temp.val = data;
temp.left = null ;
temp.right = null ;
return temp;
} // Function to check if the // tree is even-odd tree static bool isEvenOddBinaryTree(Node root)
{ if (root == null )
return true ;
// Stores nodes of each level
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
// Store the current level
// of the binary tree
int level = 0;
// Traverse until the
// queue is empty
while (q.Count != 0)
{
// Stores the number of nodes
// present in the current level
int size = q.Count;
for ( int i = 0; i < size; i++)
{
Node node = q.Dequeue();
// Check if the level
// is even or odd
if (level % 2 == 0)
{
if (node.val % 2 == 1)
return false ;
}
else if (level % 2 == 1)
{
if (node.val % 2 == 0)
return false ;
}
// Add the nodes of the next
// level into the queue
if (node.left != null )
{
q.Enqueue(node.left);
}
if (node.right != null )
{
q.Enqueue(node.right);
}
}
// Increment the level count
level++;
}
return true ;
} // Driver Code public static void Main(String[] args)
{ // Construct a Binary Tree
Node root = null ;
root = newNode(2);
root.left = newNode(3);
root.right = newNode(9);
root.left.left = newNode(4);
root.left.right = newNode(10);
root.right.right = newNode(6);
// Check if the binary tree
// is even-odd tree or not
if (isEvenOddBinaryTree(root))
{
Console.WriteLine( "YES" );
}
else
{
Console.WriteLine( "NO" );
}
} } // This code is contributed by Princi Singh |
<script> // Javascript program for the above approach // Tree node class Node { constructor(data)
{
this .left = null ;
this .right = null ;
this .val = data;
}
} // Function to return new tree node function newNode(data)
{ let temp = new Node(data);
return temp;
} // Function to check if the // tree is even-odd tree function isEvenOddBinaryTree(root)
{ if (root == null )
return true ;
// Stores nodes of each level
let q = [];
q.push(root);
// Store the current level
// of the binary tree
let level = 0;
// Traverse until the
// queue is empty
while (q.length > 0)
{
// Stores the number of nodes
// present in the current level
let size = q.length;
for (let i = 0; i < size; i++)
{
let node = q[0];
q.shift();
// Check if the level
// is even or odd
if (level % 2 == 0)
{
if (node.val % 2 == 1)
return false ;
}
else if (level % 2 == 1)
{
if (node.val % 2 == 0)
return false ;
}
// Add the nodes of the next
// level into the queue
if (node.left != null )
{
q.push(node.left);
}
if (node.right != null )
{
q.push(node.right);
}
}
// Increment the level count
level++;
}
return true ;
} // Driver code // Construct a Binary Tree let root = null ;
root = newNode(2); root.left = newNode(3); root.right = newNode(9); root.left.left = newNode(4); root.left.right = newNode(10); root.right.right = newNode(6); // Check if the binary tree // is even-odd tree or not if (isEvenOddBinaryTree(root))
{ document.write( "YES" );
} else { document.write( "NO" );
} // This code is contributed by suresh07 </script> |
YES
Time Complexity: O(N)
Auxiliary Space: O(N)
Method 2 (Using parent child difference)
Approach:
The idea is to check for the absolute difference between the child and parent node.
1. If the root node is odd, return “NO“.
2. If root node is even, then the child nodes should be odd, so difference should always come as odd. In true case return “YES“, else return “NO“.
Below is the implementation of the above approach:
#include <bits/stdc++.h> using namespace std;
// tree node struct Node
{ int data;
Node *left, *right;
}; // returns a new // tree Node Node* newNode( int data)
{ Node* temp = new Node();
temp->data = data;
temp->left = temp->right = NULL;
return temp;
} // Utility function to recursively traverse tree and check the diff between child nodes bool BSTUtil(Node * root){
if (root==NULL)
return true ;
//if left nodes exist and absolute difference between left child and parent is divisible by 2, then return false
if (root->left!=NULL && abs (root->data - root->left->data)%2==0)
return false ;
//if right nodes exist and absolute difference between right child and parent is divisible by 2, then return false
if (root->right!=NULL && abs (root->data - root->right->data)%2==0)
return false ;
//recursively traverse left and right subtree
return BSTUtil(root->left) && BSTUtil(root->right);
} // Utility function to check if binary tree is even-odd binary tree bool isEvenOddBinaryTree(Node * root){
if (root==NULL)
return true ;
// if root node is odd, return false
if (root->data%2 != 0)
return false ;
return BSTUtil(root);
} // driver program int main()
{ // construct a tree
Node* root = newNode(5);
root->left = newNode(2);
root->right = newNode(6);
root->left->left = newNode(1);
root->left->right = newNode(5);
root->right->right = newNode(7);
root->left->right->left = newNode(12);
root->right->right->right = newNode(14);
root->right->right->left = newNode(16);
if (BSTUtil(root))
cout<< "YES" ;
else
cout<< "NO" ;
return 0;
} |
/*package whatever //do not write package name here */ import java.io.*;
class GFG {
// tree node
static class Node
{
public int data;
public Node left, right;
public Node(){
data = 0 ;
left = right = null ;
}
}
// returns a new
// tree Node
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
// Utility function to recursively traverse tree and check the diff between child nodes
static boolean BSTUtil(Node root){
if (root == null )
return true ;
//if left nodes exist and absolute difference between left child and parent is divisible by 2, then return false
if (root.left != null && Math.abs(root.data - root.left.data) % 2 == 0 )
return false ;
//if right nodes exist and absolute difference between right child and parent is divisible by 2, then return false
if (root.right != null && Math.abs(root.data - root.right.data) % 2 == 0 )
return false ;
//recursively traverse left and right subtree
return BSTUtil(root.left) && BSTUtil(root.right);
}
// Utility function to check if binary tree is even-odd binary tree
static boolean isEvenOddBinaryTree(Node root){
if (root == null )
return true ;
// if root node is odd, return false
if (root.data% 2 != 0 )
return false ;
return BSTUtil(root);
}
// Driver Code
public static void main(String args[])
{
// construct a tree
Node root = newNode( 5 );
root.left = newNode( 2 );
root.right = newNode( 6 );
root.left.left = newNode( 1 );
root.left.right = newNode( 5 );
root.right.right = newNode( 7 );
root.left.right.left = newNode( 12 );
root.right.right.right = newNode( 14 );
root.right.right.left = newNode( 16 );
if (BSTUtil(root))
System.out.println( "YES" );
else
System.out.println( "NO" );
}
} // This code is contributed by shinjanpatra |
# tree node class Node:
def __init__( self ):
self .data = 0
self .left = self .right = None
# returns a new # tree Node def newNode(data):
temp = Node()
temp.data = data
temp.left = temp.right = None
return temp
# Utility function to recursively traverse tree # and check the diff between child nodes def BSTUtil(root):
if (root = = None ):
return True
# if left nodes exist and absolute difference between
# left child and parent is divisible by 2, then return False
if (root.left ! = None and abs (root.data - root.left.data) % 2 = = 0 ):
return False
# if right nodes exist and absolute difference between
# right child and parent is divisible by 2, then return False
if (root.right ! = None and abs (root.data - root.right.data) % 2 = = 0 ):
return False
# recursively traverse left and right subtree
return BSTUtil(root.left) and BSTUtil(root.right)
# Utility function to check if binary tree is even-odd binary tree def isEvenOddBinaryTree(root):
if (root = = None ):
return True
# if root node is odd, return False
if (root.data % 2 ! = 0 ):
return False
return BSTUtil(root)
# Driver Code # construct a tree root = newNode( 5 )
root.left = newNode( 2 )
root.right = newNode( 6 )
root.left.left = newNode( 1 )
root.left.right = newNode( 5 )
root.right.right = newNode( 7 )
root.left.right.left = newNode( 12 )
root.right.right.right = newNode( 14 )
root.right.right.left = newNode( 16 )
if (BSTUtil(root)):
print ( "YES" )
else :
print ( "NO" )
# This code is contributed by shinjanpatra |
// C# code for the above approach using System;
class GFG
{ // tree node
class Node
{
public int data;
public Node left, right;
public Node()
{
data = 0;
left = right = null ;
}
}
// returns a new
// tree Node
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
// Utility function to recursively traverse
// tree and check the diff between child nodes
static bool BSTUtil(Node root)
{
if (root == null )
return true ;
//if left nodes exist and absolute difference
// between left child and parent is divisible by 2, then return false
if (root.left != null && Math.Abs(root.data - root.left.data) % 2 == 0)
return false ;
// if right nodes exist and absolute difference
// between right child and parent is divisible by 2, then return false
if (root.right != null && Math.Abs(root.data - root.right.data) % 2 == 0)
return false ;
// recursively traverse left and right subtree
return BSTUtil(root.left) && BSTUtil(root.right);
}
// Utility function to check if binary tree is even-odd binary tree
static bool isEvenOddBinaryTree(Node root)
{
if (root == null )
return true ;
// if root node is odd, return false
if (root.data % 2 != 0)
return false ;
return BSTUtil(root);
}
// Driver Code
static void Main( string [] args)
{
// construct a tree
Node root = newNode(5);
root.left = newNode(2);
root.right = newNode(6);
root.left.left = newNode(1);
root.left.right = newNode(5);
root.right.right = newNode(7);
root.left.right.left = newNode(12);
root.right.right.right = newNode(14);
root.right.right.left = newNode(16);
if (BSTUtil(root))
Console.WriteLine( "YES" );
else
Console.WriteLine( "NO" );
}
} // This code is contributed by Potta Lokesh |
<script> // tree node class Node{ constructor(){
this .data = 0
this .left = this .right = null
}
} // returns a new // tree Node function newNode(data){
let temp = new Node()
temp.data = data
temp.left = temp.right = null
return temp
} // Utility function to recursively traverse tree // and check the diff between child nodes function BSTUtil(root){
if (root == null )
return true
// if left nodes exist and absolute difference between
// left child and parent is divisible by 2, then return false
if (root.left != null && Math.abs(root.data - root.left.data) % 2 == 0)
return false
// if right nodes exist and absolute difference between
// right child and parent is divisible by 2, then return false
if (root.right != null && Math.abs(root.data - root.right.data) % 2 == 0)
return false
// recursively traverse left and right subtree
return BSTUtil(root.left) && BSTUtil(root.right)
} // Utility function to check if binary tree is even-odd binary tree function isEvenOddBinaryTree(root){
if (root == null )
return true
// if root node is odd, return false
if (root.data%2 != 0)
return false
return BSTUtil(root)
} // Driver Code // construct a tree let root = newNode(5) root.left = newNode(2) root.right = newNode(6) root.left.left = newNode(1) root.left.right = newNode(5) root.right.right = newNode(7) root.left.right.left = newNode(12) root.right.right.right = newNode(14) root.right.right.left = newNode(16) if (BSTUtil(root))
document.write( "YES" , "</br>" )
else document.write( "NO" , "</br>" )
// This code is contributed by shinjanpatra </script> |
YES
Time Complexity: O(N)
Auxiliary Space: O(1)
Another Approach(Using recursion):
A simple and efficient approach as compared to above approach.
Follow the below steps to solve the given problem:
1). We simply traverse the whole binary tree recursively in inorder fashing and keep track to level at each node.
2). We will check at each level that current node data is follow the even-odd tree constraints. If the node don’t follow the constraint the we store the false in ans and simply return.
3). In driver code we will print our answer based on ans variable.
Below is the implementation of above approach:
// C++ Program for the above approach #include <bits/stdc++.h> using namespace std;
// structure of tree node struct Node{
int data;
Node *left, *right;
}; // returns a new tree node Node* newNode( int data){
Node* temp = new Node();
temp->data = data;
temp->left = temp->right = NULL;
return temp;
} //function to check if binary tree is even-odd binary tree void isEvenOddBinaryTree(Node * root, bool & ans, int level){
// base case
if (root == NULL) return ;
isEvenOddBinaryTree(root->left, ans, level+1);
// checking for even level
if (level % 2 == 0){
if (root->data % 2 != 0) ans = false ;
}
// checking for odd level
else {
if (root->data % 2 == 0) ans = false ;
}
isEvenOddBinaryTree(root->right, ans, level+1);
} // driver program to test above function int main(){
// Construct a Binary Tree
Node *root = NULL;
root = newNode(2);
root->left = newNode(3);
root->right = newNode(9);
root->left->left = newNode(4);
root->left->right = newNode(10);
root->right->right = newNode(6);
bool ans = true ;
isEvenOddBinaryTree(root, ans, 0);
if (ans)
cout<< "YES" ;
else
cout<< "NO" ;
return 0;
} // THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002) |
// Java code to implement the above approach import java.io.*;
import java.util.*;
// structure of tree node class Node {
int data;
Node left, right;
public Node( int data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
} class GFG {
// function to check if binary tree is even-odd binary
// tree
static void isEvenOddBinaryTree(Node root, boolean ans,
int level)
{
// base case
if (root == null )
return ;
isEvenOddBinaryTree(root.left, ans, level + 1 );
// checking for even level
if (level % 2 == 0 ) {
if (root.data % 2 != 0 )
ans = false ;
}
// checking for odd level
else {
if (root.data % 2 == 0 )
ans = false ;
}
isEvenOddBinaryTree(root.right, ans, level + 1 );
}
public static void main(String[] args)
{
// Construct a Binary Tree
Node root = null ;
root = new Node( 2 );
root.left = new Node( 3 );
root.right = new Node( 9 );
root.left.left = new Node( 4 );
root.left.right = new Node( 10 );
root.right.right = new Node( 6 );
boolean ans = true ;
isEvenOddBinaryTree(root, ans, 0 );
if (ans)
System.out.println( "YES" );
else
System.out.println( "NO" );
}
} // This code is contributed by karthik. |
# Python program for the above approach # class of node class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
# returns a new node def newNode(data):
return Node(data)
# furction to check if binary tree is even - odd binary tree ans = True
def isEvenOddBinaryTree(root, level):
global ans
# base case
if (root is None ):
return
isEvenOddBinaryTree(root.left, level + 1 )
# check for even level
if (level % 2 = = 0 ):
if (root.data % 2 ! = 0 ):
ans = False
else :
if (root.data % 2 = = 0 ):
ans = False
isEvenOddBinaryTree(root.right, level + 1 )
# driver program to test above function # construct a binary tree root = None
root = newNode( 2 )
root.left = newNode( 3 )
root.right = newNode( 9 )
root.left.left = newNode( 4 )
root.left.right = newNode( 10 )
root.right.right = newNode( 6 )
isEvenOddBinaryTree(root, 0 )
if (ans):
print ( "Yes" )
else :
print ( "No" )
|
// C# code to implement the above approach using System;
using System.Collections;
class Gfg
{ // structure of tree node
class Node{
public int data;
public Node left, right;
public Node( int data)
{
this .data=data;
this .left= null ;
this .right= null ;
}
}
//function to check if binary tree is even-odd binary tree
static void isEvenOddBinaryTree(Node root, bool ans, int level)
{
// base case
if (root == null )
return ;
isEvenOddBinaryTree(root.left, ans, level+1);
// checking for even level
if (level % 2 == 0){
if (root.data % 2 != 0)
ans = false ;
}
// checking for odd level
else {
if (root.data % 2 == 0)
ans = false ;
}
isEvenOddBinaryTree(root.right, ans, level+1);
}
// driver program to test above function
static void Main( string [] args)
{
// Construct a Binary Tree
Node root = null ;
root = new Node(2);
root.left = new Node(3);
root.right = new Node(9);
root.left.left = new Node(4);
root.left.right = new Node(10);
root.right.right = new Node(6);
bool ans = true ;
isEvenOddBinaryTree(root, ans, 0);
if (ans)
Console.Write( "YES" );
else
Console.Write( "NO" );
}
} // This code is contributed by poojaagarwal2. |
// JavaScript Program for the above approach // structure of node class Node{ constructor(data){
this .data = data;
this .left = null ;
this .right = null ;
}
} // returns a new node function newNode(data){
return new Node(data);
} // function to check if binary tree is even - odd binary tree let ans = true ;
function isEvenOddBinaryTree(root, level){
// base case
if (root == null ) return ;
isEvenOddBinaryTree(root.left, level+1);
// check for even level
if (level % 2 == 0){
if (root.data % 2 != 0) ans = false ;
}
// checking for odd level
else {
if (root.data % 2 == 0) ans = false ;
}
isEvenOddBinaryTree(root.right, level+1);
} // driver program to test above function // construct a binary tree let root = null ;
root = newNode(2); root.left = newNode(3); root.right = newNode(9); root.left.left = newNode(4); root.left.right = newNode(10); root.right.right = newNode(6); isEvenOddBinaryTree(root, 0); if (ans)
console.log( "YES" );
else console.log( "NO" );
// This code is contributed by KIRTI AGARWAL(KIRTIAGARWAL23121999) |
YES
Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(h) where h is the height of given binary tree.