Invert Binary Tree - Practice Coding Problems

Invert Binary Tree - Problem

Given the root of a binary tree, invert the tree by swapping all left and right children at every node, then return the modified root.

Inverting a binary tree means creating a mirror image of the original tree. Every left child becomes a right child, and every right child becomes a left child, recursively throughout the entire tree structure.

Goal: Transform the binary tree into its horizontal mirror reflection.
Input: The root node of a binary tree (or null for empty tree)
Output: The root node of the inverted binary tree

For example, if you have a tree where node 2 is the left child of root 4, after inversion, node 2 becomes the right child of root 4.

Input & Output

example_1.py — Standard Binary Tree

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

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

💡 Note: The tree is inverted horizontally. Node 2 (originally left child of 4) becomes right child, and node 7 (originally right child) becomes left child. This pattern continues recursively for all subtrees.

example_2.py — Simple Two-Node Tree

$ Input: root = [2,1,3]

› Output: [2,3,1]

💡 Note: Left child 1 and right child 3 are swapped. The root remains at position 2 but its children are inverted.

example_3.py — Empty Tree Edge Case

$ Input: root = []

› Output: []

💡 Note: An empty tree remains empty after inversion. This is our base case - there are no nodes to swap.

Constraints

The number of nodes in the tree is in the range [0, 100]
Node values are in the range [-100, 100]
Follow-up: This problem was inspired by Max Howell's tweet about being rejected by Google despite inverting binary trees daily

Visualization

Tap to expand

Understanding the Visualization

Identify Original Structure

Start with the original binary tree with nodes in their initial left-right positions

Apply Recursive Logic

At each node, recursively invert left and right subtrees

Swap Children

Swap the inverted left and right subtrees at current node

Return Inverted Tree

The result is a horizontally mirrored version of the original tree

Key Takeaway

🎯 Key Insight: Tree inversion is elegantly solved through recursion - invert subtrees first, then swap them at each level!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses recursive depth-first traversal to swap left and right children at each node. With O(n) time complexity and O(h) space complexity (where h is tree height), this elegant approach leverages the tree's recursive structure to efficiently create a mirror image of the original tree.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Depth-First Approach	O(n)	O(h)	Recursively traverse and swap left and right children at each node

Recursive Depth-First Approach — Algorithm Steps

Base case: if current node is null, return null
Recursively invert the left subtree
Recursively invert the right subtree
Swap the left and right children of current node
Return the current node

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin recursion at root node 4

Process Left Subtree

Recursively invert left subtree rooted at 2

Process Right Subtree

Recursively invert right subtree rooted at 7

Swap Children

Swap the inverted left and right subtrees at root

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

struct TreeNode* invertTree(struct TreeNode* root) {
    // Base case: empty tree
    if (!root) {
        return NULL;
    }
    
    // Recursively invert subtrees
    struct TreeNode* left = invertTree(root->left);
    struct TreeNode* right = invertTree(root->right);
    
    // Swap the children
    root->left = right;
    root->right = left;
    
    return root;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once to swap its children

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, which is O(log n) for balanced trees, O(n) for skewed trees

✓ Linear Space

89.5K Views

High Frequency

~12 min Avg. Time

2.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

Recursive Depth-First Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler