Even Odd Tree - Practice Coding Problems

Even Odd Tree - Problem

Imagine a binary tree where each level follows a special alternating pattern - like floors in a magical building where each floor has its own unique rules!

A binary tree is called an Even-Odd Tree if it satisfies these enchanting conditions:

Even-indexed levels (0, 2, 4, ...): All node values must be odd numbers and arranged in strictly increasing order from left to right
Odd-indexed levels (1, 3, 5, ...): All node values must be even numbers and arranged in strictly decreasing order from left to right

Given the root of a binary tree, determine if it qualifies as an Even-Odd Tree. Return true if it does, false otherwise.

Example: Level 0 (even): [1, 5, 9] ✅ (odd, increasing) | Level 1 (odd): [4, 2] ✅ (even, decreasing)

Input & Output

example_1.py — Valid Even-Odd Tree

$ Input: root = [1,10,4,3,null,7,9,12,8,6,null,null,2]

› Output: true

💡 Note: Level 0 (even): [1] - odd values in increasing order ✓. Level 1 (odd): [10,4] - even values in decreasing order ✓. Level 2 (even): [3,7,9] - odd values in increasing order ✓. Level 3 (odd): [12,8,6,2] - even values in decreasing order ✓.

example_2.py — Invalid Parity

$ Input: root = [5,4,2,3,3,7]

› Output: false

💡 Note: Level 1 (odd): [4,2] - contains even values but not in decreasing order (4 > 2, but we need strictly decreasing). Actually, this should be decreasing, but level 2 has [3,3,7] which violates strictly increasing (3 == 3).

example_3.py — Single Node Tree

$ Input: root = [5]

› Output: true

💡 Note: Single node tree with root value 5 (odd) at level 0 (even). Since level 0 requires odd values and there's only one node, the increasing order constraint is trivially satisfied.

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁶
Level indexing starts from 0 (root is at level 0)
Tree nodes can have null children

Visualization

Tap to expand

Understanding the Visualization

Initialize BFS

Start with root node at level 0, prepare queue for level-order traversal

Process Each Level

For each level, process all nodes left to right while tracking constraints

Validate Parity

Even levels must have odd values, odd levels must have even values

Validate Ordering

Even levels need strictly increasing, odd levels need strictly decreasing

Early Termination

Return false immediately if any constraint is violated

Key Takeaway

🎯 Key Insight: Use BFS to process levels sequentially, validating both parity (odd/even) and ordering (increasing/decreasing) constraints simultaneously in a single pass for optimal O(n) performance.

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 15

The optimal solution uses BFS level-order traversal to process the tree level by level in O(n) time. For each level, we validate both parity constraints (even levels need odd values, odd levels need even values) and ordering constraints (even levels need increasing order, odd levels need decreasing order) simultaneously during traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Tree Traversals)	O(n²)	O(n)	Separate DFS for each level, then validate each level independently
BFS Level-Order Traversal (Optimal)	O(n)	O(w)	Single pass using BFS queue to validate each level as we traverse

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Use DFS to find maximum depth of tree
For each level, collect all nodes using DFS with level tracking
Validate each level's parity constraint (odd/even)
Validate each level's ordering constraint (increasing/decreasing)
Return false if any level fails validation

Visualization

Tap to expand

Step-by-Step Walkthrough

First DFS Pass

Traverse tree to collect all nodes at level 0

Second DFS Pass

Traverse tree again to collect all nodes at level 1

Continue DFS

Repeat for each level until tree is fully processed

Validate Levels

Check each level's parity and ordering constraints

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void dfs(struct TreeNode* node, int level, int** levels, int* levelSizes, int* maxLevel) {
    if (!node) return;
    
    if (level > *maxLevel) {
        *maxLevel = level;
    }
    
    if (!levels[level]) {
        levels[level] = (int*)malloc(1000 * sizeof(int));
        levelSizes[level] = 0;
    }
    
    levels[level][levelSizes[level]++] = node->val;
    dfs(node->left, level + 1, levels, levelSizes, maxLevel);
    dfs(node->right, level + 1, levels, levelSizes, maxLevel);
}

bool isEvenOddTree(struct TreeNode* root) {
    if (!root) return false;
    
    int** levels = (int**)calloc(1000, sizeof(int*));
    int* levelSizes = (int*)calloc(1000, sizeof(int));
    int maxLevel = -1;
    
    dfs(root, 0, levels, levelSizes, &maxLevel);
    
    for (int level = 0; level <= maxLevel; level++) {
        if (levelSizes[level] == 0) continue;
        
        if (level % 2 == 0) {
            for (int i = 0; i < levelSizes[level]; i++) {
                if (levels[level][i] % 2 == 0) return false;
                if (i > 0 && levels[level][i] <= levels[level][i-1]) return false;
            }
        } else {
            for (int i = 0; i < levelSizes[level]; i++) {
                if (levels[level][i] % 2 == 1) return false;
                if (i > 0 && levels[level][i] >= levels[level][i-1]) return false;
            }
        }
    }
    
    return true;
}

int main() {
    struct TreeNode* root = NULL;
    printf("%s\n", isEvenOddTree(root) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case (skewed tree), we traverse the tree d times where d is depth, leading to O(n*d) which can be O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store all nodes organized by levels, plus recursion stack space

⚡ Linearithmic Space

38.2K Views

Medium Frequency

~18 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler