Even Odd Tree

Even Odd Tree - Problem

A binary tree is named Even-Odd if it meets the following conditions:

The root of the binary tree is at level index 0, its children are at level index 1, their children are at level index 2, etc.
For every even-indexed level, all nodes at the level have odd integer values in strictly increasing order (from left to right).
For every odd-indexed level, all nodes at the level have even integer values in strictly decreasing order (from left to right).

Given the root of a binary tree, return true if the binary tree is Even-Odd, otherwise return false.

Input & Output

Example 1 — Valid Even-Odd Tree

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

› Output: true

💡 Note: Level 0: [1] (odd, single node ✓), Level 1: [10,4] (even, 10>4 decreasing ✓), Level 2: [3,7,9] (odd, 3<7<9 increasing ✓), Level 3: [12,8,6,2] (even, 12>8>6>2 decreasing ✓)

Example 2 — Invalid Ordering

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

› Output: false

💡 Note: Level 0: [5] (odd ✓), Level 1: [4,2] (even, 4>2 decreasing ✓), Level 2: [3,3,7] (odd but 3=3 not strictly increasing ✗)

Example 3 — Invalid Parity

$ Input: root = [5,9,1,3,5,7]

› Output: false

💡 Note: Level 0: [5] (odd ✓), Level 1: [9,1] (should be even but both are odd ✗)

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁶

Visualization

Tap to expand

Asked in

M Microsoft 15 A Amazon 12 F Facebook 8

The key insight is to use BFS level-order traversal to validate each level's constraints immediately. For even levels, check all values are odd and strictly increasing; for odd levels, check all values are even and strictly decreasing. Best approach is BFS with single pass. Time: O(n), Space: O(w) where w is tree width.

Common Approaches

✓ BFS Level-Order Traversal

⏱️ Time: O(n) Space: O(w)

Process the tree level by level using a queue. For each level, collect all node values and immediately validate the even-odd constraints before moving to next level.

Brute Force DFS

⏱️ Time: O(n) Space: O(n)

First traverse the tree using DFS to group all node values by their level. Then check each level separately to ensure it follows the even-odd rules for values and ordering.

BFS Level-Order Traversal — Algorithm Steps

Step 1: Use queue for level-order traversal
Step 2: For each level, validate parity and ordering as we collect values

Visualization

Tap to expand

Step-by-Step Walkthrough

Queue Processing

Process all nodes at current level from queue

Immediate Validation

Check parity and ordering for current level

Next Level

Add children to queue and continue

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(char* input) {
    if (!input || strlen(input) == 0) return NULL;
    
    // Remove brackets
    char* start = strchr(input, '[');
    char* end = strchr(input, ']');
    if (!start || !end) return NULL;
    
    start++;
    *end = '\0';
    
    if (start >= end || *start == '\0') return NULL;
    
    // Parse values
    static char* values[10000];
    int count = 0;
    
    char* token = strtok(start, ",");
    while (token && count < 10000) {
        // Remove leading/trailing spaces
        while (*token == ' ') token++;
        char* endToken = token + strlen(token) - 1;
        while (endToken > token && *endToken == ' ') {
            *endToken = '\0';
            endToken--;
        }
        values[count++] = token;
        token = strtok(NULL, ",");
    }
    
    if (count == 0) return NULL;
    
    // Build tree using BFS
    static struct TreeNode* queue[10000];
    static struct TreeNode* nodes[10000];
    
    // Create all nodes first
    for (int i = 0; i < count; i++) {
        if (strcmp(values[i], "null") == 0) {
            nodes[i] = NULL;
        } else {
            nodes[i] = createNode(atoi(values[i]));
        }
    }
    
    if (!nodes[0]) return NULL;
    
    // Connect nodes
    int queueFront = 0, queueRear = 0;
    queue[queueRear++] = nodes[0];
    int valueIndex = 1;
    
    while (queueFront < queueRear && valueIndex < count) {
        struct TreeNode* current = queue[queueFront++];
        
        // Left child
        if (valueIndex < count) {
            current->left = nodes[valueIndex++];
            if (current->left) {
                queue[queueRear++] = current->left;
            }
        }
        
        // Right child
        if (valueIndex < count) {
            current->right = nodes[valueIndex++];
            if (current->right) {
                queue[queueRear++] = current->right;
            }
        }
    }
    
    return nodes[0];
}

bool solution(struct TreeNode* root) {
    if (!root) return true;
    
    static struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int level = 0;
    
    while (front < rear) {
        int levelSize = rear - front;
        static int levelValues[1000];
        int valueCount = 0;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = queue[front++];
            levelValues[valueCount++] = node->val;
            
            if (node->left) queue[rear++] = node->left;
            if (node->right) queue[rear++] = node->right;
        }
        
        // Validate current level
        if (level % 2 == 0) {
            // Even level: odd values, strictly increasing
            for (int i = 0; i < valueCount; i++) {
                if (levelValues[i] % 2 == 0) return false;
            }
            for (int i = 1; i < valueCount; i++) {
                if (levelValues[i] <= levelValues[i-1]) return false;
            }
        } else {
            // Odd level: even values, strictly decreasing
            for (int i = 0; i < valueCount; i++) {
                if (levelValues[i] % 2 == 1) return false;
            }
            for (int i = 1; i < valueCount; i++) {
                if (levelValues[i] >= levelValues[i-1]) return false;
            }
        }
        
        level++;
    }
    
    return true;
}

int main() {
    static char input[100000];
    if (fgets(input, sizeof(input), stdin)) {
        // Remove newline
        input[strcspn(input, "\n")] = '\0';
        
        struct TreeNode* root = buildTree(input);
        bool result = solution(root);
        printf(result ? "true\n" : "false\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree

⚡ Linearithmic Space

32.5K Views

Medium Frequency

~25 min Avg. Time

892 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

BFS Level-Order Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler