# Solving Leetcode Interviews in Seconds with AI: Reverse Odd Levels of Binary Tree


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2415" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# 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 <= 105 root is a perfect binary tree.  

	# Explanation
	Here's the breakdown of the solution:

*   **Level-Order Traversal:** Perform a level-order traversal of the tree using a queue. This allows processing nodes level by level.
*   **Odd Level Identification:** Keep track of the current level during the traversal. Reverse the values of nodes at odd levels.
*   **In-Place Reversal:** Instead of creating new lists, directly swap the node values to modify the tree in-place, which optimizes space complexity.

*   **Time Complexity:** O(N), where N is the number of nodes in the tree.
*   **Space Complexity:** O(W), where W is the maximum width of the tree (which can be up to N/2 for a perfect binary tree). This is due to the queue used for level-order traversal.

	
	# Code
	```python
	from collections import deque

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def reverseOddLevels(root):
    if not root:
        return root

    queue = deque([root])
    level = 0

    while queue:
        level_size = len(queue)
        level_nodes = []

        for _ in range(level_size):
            node = queue.popleft()
            level_nodes.append(node)

            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        if level % 2 != 0:
            left, right = 0, len(level_nodes) - 1
            while left < right:
                level_nodes[left].val, level_nodes[right].val = level_nodes[right].val, level_nodes[left].val
                left += 1
                right -= 1

        level += 1

    return root
	```