Reverse Odd Levels of Binary Tree - Practice Coding Problems

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

Even levels (0,2,4,...) remain unchanged2. Odd levels (1,3,5,...) have their values reversed left-to-right3. Tree structure stays the same, only node values are modified

Understanding the Visualization

Identify Structure

Perfect binary tree ensures complete symmetry at each level

Level Classification

Determine which levels are odd (1, 3, 5, ...) and need reversal

Symmetric Pairing

Match nodes symmetrically across each odd level

Value Swapping

Exchange values between symmetric pairs at odd levels

Key Takeaway

🎯 Key Insight: Perfect binary trees have symmetric structure that allows efficient in-place swapping of values at odd levels using DFS traversal

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

Approach	Time	Space	Notes
✓ DFS with Value Swapping	O(n)	O(h)	Use DFS to traverse symmetrically and swap values at odd levels

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>

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

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