Reverse Odd Levels of Binary Tree

Reverse Odd Levels of Binary Tree - Problem

Transform a Perfect Binary Tree by Reversing Odd Levels

Given the root of a perfect binary tree, your task is to reverse the node values at each odd-numbered level of the tree.

🌳 What makes this interesting:
• A perfect binary tree has all parent nodes with exactly two children
• All leaf nodes are at the same level
• We need to reverse values within each odd level, not the structure

For example, if level 3 contains values [2,1,3,4,7,11,29,18], after reversal it becomes [18,29,11,7,4,3,1,2].

Level numbering starts at 0:
• Level 0 (root): Keep as-is
• Level 1: Reverse values
• Level 2: Keep as-is
• Level 3: Reverse values
• And so on...

Return the root of the modified tree with odd levels reversed.

Input & Output

example_1.py — Basic Perfect Binary Tree

$ Input: root = [2,3,5,8,13,21,34]

› Output: [2,5,3,8,13,21,34]

💡 Note: Level 0: [2] stays the same. Level 1: [3,5] becomes [5,3] (reversed). Level 2: [8,13,21,34] stays the same. The tree structure remains unchanged, only values at odd levels are reversed.

example_2.py — Larger Perfect Tree

$ Input: root = [7,13,11]

› Output: [7,11,13]

💡 Note: Level 0: [7] stays the same. Level 1: [13,11] becomes [11,13] (reversed). This is a simple 2-level perfect binary tree where only the children values are swapped.

example_3.py — Single Node Tree

$ Input: root = [0]

› Output: [0]

💡 Note: A tree with only one node has no odd levels to reverse (level 0 is even), so it remains unchanged. This is an edge case where the tree is trivially perfect.

Constraints

The number of nodes in the tree is in the range [1, 2¹⁴]
0 ≤ Node.val ≤ 10⁵
root is a perfect binary tree

Visualization

Tap to expand

Asked in

⊞ Microsoft 25 a Amazon 18 G Google 15 f Meta 12

The optimal approach uses DFS with symmetric traversal to efficiently reverse odd levels. By traversing the perfect binary tree symmetrically and swapping values at odd levels, we achieve O(n) time complexity with minimal space overhead. The key insight is that perfect binary trees allow us to easily identify and swap symmetric node pairs during traversal.

Common Approaches

✓ DFS with Value Swapping

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

Use depth-first search to traverse the tree. At each odd level, traverse nodes from both ends simultaneously and swap their values. This approach leverages the perfect binary tree property where we can easily find corresponding nodes.

DFS with Value Swapping — Algorithm Steps

Start DFS from root with level 0
For each level, check if it's odd
If odd level, use two pointers to traverse from both ends
Swap values of corresponding nodes
Recursively process child subtrees

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin DFS from root, considering its children

Check Level Parity

For each pair of nodes, check if level is odd

Swap if Odd

Swap values of symmetric nodes if at odd level

Recurse Symmetrically

Continue DFS with left-right and right-left pairs

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void dfs(struct TreeNode* left, struct TreeNode* right, int level) {
    if (!left || !right) return;
    
    // If current level is odd, swap values
    if (level % 2 == 1) {
        int temp = left->val;
        left->val = right->val;
        right->val = temp;
    }
    
    // Recursively process children
    dfs(left->left, right->right, level + 1);
    dfs(left->right, right->left, level + 1);
}

struct TreeNode* reverseOddLevels(struct TreeNode* root) {
    if (root) {
        dfs(root->left, root->right, 1);
    }
    return root;
}

struct TreeNode* buildTreeFromArray(int* arr, int size) {
    if (size == 0) return NULL;
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = arr[0];
    root->left = NULL;
    root->right = NULL;
    
    struct TreeNode** queue = (struct TreeNode**)malloc(size * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size) {
            node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->left->val = arr[i];
            node->left->left = NULL;
            node->left->right = NULL;
            queue[rear++] = node->left;
            i++;
        }
        if (i < size) {
            node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->right->val = arr[i];
            node->right->left = NULL;
            node->right->right = NULL;
            queue[rear++] = node->right;
            i++;
        }
    }
    
    free(queue);
    return root;
}

void treeToArray(struct TreeNode* root, int* result, int* size) {
    if (!root) {
        *size = 0;
        return;
    }
    
    struct TreeNode** queue = (struct TreeNode**)malloc(20000 * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    *size = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        result[(*size)++] = node->val;
        if (node->left) queue[rear++] = node->left;
        if (node->right) queue[rear++] = node->right;
    }
    
    free(queue);
}

int main() {
    char input[100000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = '\0';
    
    if (strcmp(input, "[]") == 0) {
        printf("[]\n");
        return 0;
    }
    
    // Parse array format [1,2,3]
    int arr[20000];
    int size = 0;
    
    char* arrStr = input + 1; // Skip opening bracket
    arrStr[strlen(arrStr) - 1] = '\0'; // Remove closing bracket
    
    if (strlen(arrStr) > 0) {
        char* token = strtok(arrStr, ",");
        while (token != NULL) {
            arr[size++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    struct TreeNode* root = buildTreeFromArray(arr, size);
    struct TreeNode* resultRoot = reverseOddLevels(root);
    
    int result[20000];
    int resultSize;
    treeToArray(resultRoot, result, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once during DFS traversal

✓ Linear Growth

Space Complexity

O(h)

Where h is height of tree due to recursion stack

✓ Linear Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

DFS with Value Swapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler