Open In App

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

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``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 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 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 q = ``new` `Queue();``  ``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

 ``

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 ``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;``}`

## Java

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

## Python3

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

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

## Javascript

 ``

Output

`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++

 `// C++ Program for the above approach``#include ``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

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

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

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

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

Output

`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.