- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Check if a Binary Tree contains node values in strictly increasing and decreasing order at even and odd levels
Level of a Binary Tree − In a binary tree, the level of the node refers to its distance from the root node. The root node is considered at level 0, its immediate children are at level 1, their children at level 2 and so on.
Levels of a binary tree are explained in the following example,
A <- Level 0 / \ B C <- Level 1 / \ / \ D E F G <- Level 2
Problem Statement
Given a binary tree, check if it contains node values in strictly increasing and decreasing order at even and odd intervals.
Sample Example 1
Input
2 / \ 9 7 / \ / \ 1 5 6 8
Output
True
Explanation
Level 1 - 9 and 7 node values are strictly decreasing
Level 2 - 1, 5, 6, and 8 node values are strictly increasing
Thus, the given tree has node values in strictly increasing and decreasing order for even and odd levels.
Sample Example 2
Input
8 / \ 9 8 / \ 4 3
Output
False
Explanation
Level 1 - 9 and 8 node values are strictly decreasing
Level 2 - 4 and 3 node values are not strictly increasing
Thus, the given tree has node values in strictly increasing and decreasing order for even and odd levels.
Solution Approach
A queue is used to perform the level order traversal of the binary tree and the queue initially has the root node in it. As the function traverses, the level of the tree is tracked starting with level 0. At each level, the node values are stored in a vector to check if they are strictly increasing or strictly decreasing or none. Then the level of the nodes is checked. If the node level is even and the node values are strictly increasing or if the level is odd and the node values are strictly decreasing, then return True else return False.
Pseudocode −
function checkEvenOddLevel(root): if root is NULL: return true queue = empty queue enqueue root to queue level = 0 while queue is not empty: vec = empty vector size = size of queue for i = 0 to size - 1: node = dequeue from queue add node's value to vec if node has left child: enqueue left child to queue if node has right child: enqueue right child to queue if level is even: for i = 0 to size of vec - 2: if vec[i + 1] <= vec[i]: return false if level is odd: for i = 0 to size of vec - 2: if vec[i + 1] >= vec[i]: return false increment level by 1 return true root = create binary tree if checkEvenOddLevel(root): print "True" else: print "False"
Exmaple: C++ Implementation
The following code checks if the node values are strictly increasing or decreasing for even and odd levels of the binary tree.
// C++ program for the above approach #include <iostream> #include <vector> #include <queue> using namespace std; struct Node { int val; Node* left, *right; }; Node* newNode(int data) { Node* temp = new Node(); temp->val = data; temp->left = NULL; temp->right = NULL; return temp; } // Function to check if given binary tree satisfies the required conditions bool checkEvenOddLevel(Node* root) { if (root == NULL) return true; // Queue to store nodes of each level queue<Node*> q; q.push(root); // Stores the current level of the binary tree int level = 0; // Traverse until the queue is empty while (!q.empty()) { vector<int> vec; // 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(); vec.push_back(node->val); // Insert left and right child of node into the queue if (node->left != NULL) q.push(node->left); if (node->right != NULL) q.push(node->right); q.pop(); } // If the level is even if (level % 2 == 0) { // If the nodes in this level are in strictly increasing order or not for (int i = 0; i < vec.size() - 1; i++) { if (vec[i + 1] > vec[i]) continue; return false; } } // If the level is odd else if (level % 2 == 1) { // If the nodes in this level are in strictly decreasing order or not for (int i = 0; i < vec.size() - 1; i++) { if (vec[i + 1] < vec[i]) continue; return false; } } // Increment the level count level++; } return true; } int main(){ // Construct a Binary Tree Node* root = NULL; root = newNode(2); root->left = newNode(6); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(7); root->right->right = newNode(11); root->left->left->left = newNode(10); root->left->left->right = newNode(5); root->left->right->right = newNode(1); // Function Call if (checkEvenOddLevel(root)) cout << "True"; else cout << "False"; return 0; }
Output
True
Time Complexity − O(n) as we are traversing the entire tree once
Space Complexity − O(n) due to the space used by queue and vector.
Conclusion
In conversation, we discussed the problem of checking if a binary tree contains node values in strictly increasing and decreasing order at even and odd levels. It performs a level order traversal using a queue and checks the order of values at each level based on whether the level is even or odd. The code has a time complexity of O(N) and a space complexity of O(N), where N is the number of nodes in the binary tree. It can determine if the binary tree satisfies the required conditions efficiently and is suitable for practical use.