Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if a Binary Tree is an Even-Odd Tree or not

  • Difficulty Level : Medium
  • Last Updated : 03 Aug, 2021

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  6

Output: 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  5

Output: NO 
 

Approach: Follow the steps below to solve the problem: 

  1. 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.
  2. If any node at an odd level is found to have odd value or vice-versa, then print “NO“.
  3. Otherwise, after complete traversal of the tree, print “YES“.

Below is the implementation of the above approach:

C++




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



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



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



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



<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>
Output: 
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:
C++



#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;
}
Output
YES
Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Next

Print the middle nodes of each level of a Binary Tree
Recommended Articles
Page :
Check whether a binary tree is a full binary tree or not
08, Feb 15
Check whether a binary tree is a full binary tree or not | Iterative Approach
19, Dec 17
Check whether a given binary tree is skewed binary tree or not?
18, Nov 18
Check whether a binary tree is a complete tree or not | Set 2 (Recursive Solution)
14, Feb 15
Check if a binary tree is subtree of another binary tree | Set 1
15, Aug 11
Check if a binary tree is subtree of another binary tree | Set 2
26, Jul 14
Check if a binary tree is subtree of another binary tree using preorder traversal : Iterative
08, Apr 20
Check if a Binary tree is Subtree of another Binary tree | Set 3
24, Feb 22
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
19, Jan 18
A program to check if a binary tree is BST or not
21, Nov 09
Check whether a given binary tree is perfect or not
09, Jun 17
Check if an array represents Inorder of Binary Search tree or not
29, Jun 17
Check if a Binary Tree (not BST) has duplicate values
26, Jan 18
Check if a binary tree is sorted level-wise or not
25, Jun 18
Check if Nodes in Top view of a Binary Tree forms a Palindrome Number or not
18, Feb 21
Check if Inorder traversal of a Binary Tree is palindrome or not
05, Jun 20
Iterative approach to check if a Binary Tree is BST or not
10, Dec 20
Check if level-wise Decimal equivalent of Binary Tree forms a Monotonic sequence or not
23, Mar 22
Check whether a given Binary Tree is Complete or not | Set 1 (Iterative Solution)
06, Sep 12
Binary Tree to Binary Search Tree Conversion
15, Jun 12
Convert a Binary Tree to Threaded binary tree | Set 1 (Using Queue)
29, Oct 14
Convert a Binary Tree to Threaded binary tree | Set 2 (Efficient)
14, Feb 17
Minimum swap required to convert binary tree to binary search tree
28, Jan 17
Binary Tree | Set 3 (Types of Binary Tree)
05, May 15
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
lavishgarg26
@lavishgarg26
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!