Reverse Odd Levels of Binary Tree - Solution & Explanation
Problem Statement
Given the root of a perfect binary tree, reverse the node values at each odd level of the tree.
- For example, suppose the node values at level 3 are
[2,1,3,4,7,11,29,18], then it should become[18,29,11,7,4,3,1,2].
Return the root of the reversed tree.
A binary tree is perfect if all parent nodes have two children and all leaves are on the same level.
The level of a node is the number of edges along the path between it and the root node.
Example 1:
Input: root = [2,3,5,8,13,21,34] Output: [2,5,3,8,13,21,34] Explanation: The tree has only one odd level. The nodes at level 1 are 3, 5 respectively, which are reversed and become 5, 3.
Example 2:
Input: root = [7,13,11] Output: [7,11,13] Explanation: The nodes at level 1 are 13, 11, which are reversed and become 11, 13.
Example 3:
Input: root = [0,1,2,0,0,0,0,1,1,1,1,2,2,2,2] Output: [0,2,1,0,0,0,0,2,2,2,2,1,1,1,1] Explanation: The odd levels have non-zero values. The nodes at level 1 were 1, 2, and are 2, 1 after the reversal. The nodes at level 3 were 1, 1, 1, 1, 2, 2, 2, 2, and are 2, 2, 2, 2, 1, 1, 1, 1 after the reversal.
Constraints:
- The number of nodes in the tree is in the range
[1, 214]. 0 <= Node.val <= 105rootis a perfect binary tree.
Approach Overview
Problem Overview: Given the root of a perfect binary tree, reverse the node values at every odd level of the tree. Level 0 (the root) stays unchanged, level 1 gets reversed, level 2 stays the same, and so on. Only the values are swapped—tree structure remains unchanged.
Approach 1: Brute Force Method using Level Order Traversal (O(n) time, O(n) space)
This approach uses a classic Breadth-First Search to process the tree level by level. Use a queue to perform level order traversal and store nodes of the current level in an array. If the level index is odd, reverse the values in that array by swapping elements from both ends using a two-pointer technique. Then write the reversed values back into the nodes. The algorithm touches each node exactly once, so the time complexity is O(n), while the queue and temporary storage require O(n) space in the worst case.
This method is straightforward and easy to implement. It works well if you naturally think about trees in terms of levels. However, it temporarily stores an entire level of nodes, which adds extra memory overhead.
Approach 2: Optimized Symmetric DFS (O(n) time, O(h) space)
The optimized solution exploits the symmetry of a perfect binary tree. Instead of collecting values by level, traverse the tree in pairs of mirrored nodes using Depth-First Search. Start with the root's left and right children. When visiting a pair of symmetric nodes, check the current depth: if the depth is odd, swap their values. Then recursively process the pairs (left.left, right.right) and (left.right, right.left).
This technique directly swaps mirrored nodes without storing entire levels. Every node is visited once, giving O(n) time complexity. The recursion stack only grows to the height of the tree, which is O(h) (or O(log n) for a perfect tree). Because it avoids extra arrays or queues, the memory usage is significantly lower.
Recommended for interviews: The symmetric DFS approach is usually what interviewers expect. It shows you recognize the structural symmetry of a perfect binary tree and can leverage it for an efficient in-place solution. The brute force BFS method still demonstrates solid understanding of level-order traversal, but the DFS pairing technique highlights deeper tree manipulation skills.
Approach 1: Approach 1: Brute Force Method
This approach involves iterating through each conceivable solution space or list and checking which solutions satisfy the given problem. It's straightforward but may not be optimized for time complexity, making it suitable for problems with limited input sizes or as a stepping stone to more efficient methods.
This C program defines a function to print "Hello, World!" and calls that function within the main function.
Complexity
Time Complexity: O(1)
Space Complexity: O(1)
Approach 2: Approach 2: Optimized Iterative Approach
This approach leverages tailored iteration strategies to resolve the problem more efficiently, especially when dealing with larger datasets. It eliminates some of the redundancies present in a brute force solution.
This C code scans the string using a counting array to track the frequency of each character. It promptly returns any character that appears more than once.
Complexity
Time Complexity: O(n)
Space Complexity: O(1) because number of characters is constant.
Approach 3: BFS
We can use the Breadth-First Search (BFS) method, using a queue q to store the nodes of each level, and a variable i to record the current level. If i is odd, we reverse the values of the nodes at the current level.
The time complexity is O(n), and the space complexity is O(n). Here, n is the number of nodes in the binary tree.
Complexity Comparison
| Approach | Complexity |
|---|---|
| Approach 1: Brute Force Method | Time Complexity: O(1) |
| Approach 2: Optimized Iterative Approach | Time Complexity: O(n) |
| BFS | — |
Detailed Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Brute Force Level Order Traversal (BFS) | O(n) | O(n) | When implementing a simple level-by-level traversal or when clarity is preferred over memory optimization |
| Symmetric DFS Node Pair Swapping | O(n) | O(h) | Best for perfect binary trees where mirrored nodes can be processed together with minimal extra memory |
Video Solution
Reverse Odd Levels of Binary Tree | Detailed | DFS | BFS | Leetcode 2415 | codestorywithMIK • codestorywithMIK • 8,893 views views
Watch 9 more video solutions →Frequently Asked Questions
Is Reverse Odd Levels of Binary Tree easy or hard?
Reverse Odd Levels of Binary Tree Python/Java solution
How to solve Reverse Odd Levels of Binary Tree in O(n)?
What is the best approach for Reverse Odd Levels of Binary Tree?
Is Reverse Odd Levels of Binary Tree asked at Google/Amazon/Meta?
What data structure is used in Reverse Odd Levels of Binary Tree?
What is the time complexity of Reverse Odd Levels of Binary Tree?
Ready to solve this problem?
Practice Reverse Odd Levels of Binary Tree with our built-in code editor and test cases.
Practice on FleetCode