How do you approach Invert Binary Tree?

Build a tree structure from the array, then swap left and right children recursively.

What is the time complexity of Invert Binary Tree?

Time complexity: O(n) - visit each node once. Space complexity: O(n) - for the tree structure and output array.

What are common mistakes on Invert Binary Tree?

Handling the null node deep in the recursion instead of as the first base case. Returning early from a subtree when the answer needs both sides explored. Confusing height with depth. One counts up from the node, the other down from the root, and the off-by-one is silent.

gitGood.dev

← Back to problems

Invert Binary Tree

EasyData Structures

Description

Given the root of a binary tree represented as a level-order array (with `null` for missing nodes), invert the tree and return the inverted tree as a level-order array. Inverting a binary tree means swapping every left node with its corresponding right node. For example, `[4, 2, 7, 1, 3, 6, 9]` represents: ``` 4 / \ 2 7 / \ / \ 1 3 6 9 ``` After inverting: ``` 4 / \ 7 2 / \ / \ 9 6 3 1 ``` Return `[4, 7, 2, 9, 6, 3, 1]`.

Example 1

Input: root = [4, 2, 7, 1, 3, 6, 9]

Output: [4, 7, 2, 9, 6, 3, 1]

Example 2

Input: root = [2, 1, 3]

Output: [2, 3, 1]

Example 3

Input: root = []

Output: []

Constraints

- The number of nodes in the tree is in the range [0, 100]. - -100 <= Node.val <= 100

Invert Binary Tree: approach, complexity and pitfalls

An easy trees problem, graded against 6 test cases (3 of them hidden).

The pattern: Trees

Recursive traversal of binary trees and BSTs - depth, validation, and path problems.

Reach for it when you see: A TreeNode input, or anything about depth, ancestry, or in-order ordering.

More Treesproblems →

If you are stuck

Show the 3-step hint ladder

Build a tree structure from the array, then swap left and right children recursively.
After inverting, convert the tree back to a level-order array.
For a complete binary tree, you could also work directly on the array by swapping elements at each level.

The optimal approach

Show the approach: Recursive Tree Inversion

Build a tree from the level-order array, recursively swap left and right children at every node, then convert back to a level-order array.

For each node, swap its left and right subtrees, then recursively invert each subtree.

Time: O(n) - visit each node once
Space: O(n) - for the tree structure and output array

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Empty input. At least one case passes an empty collection. Make sure your loop bounds and any "first element" read survive a length of zero.
Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.
Null values. A null appears in the input. Guard your dereferences rather than relying on the shape of the sample case.

Common Trees mistakes

These apply to the pattern as a whole, not just this problem.

Handling the null node deep in the recursion instead of as the first base case.
Returning early from a subtree when the answer needs both sides explored.
Confusing height with depth. One counts up from the node, the other down from the root, and the off-by-one is silent.