Binary Tree Mirror - Problem

Given the root of a binary tree, create its mirror image by swapping the left and right children of every node in the tree.

In a mirror image, every node's left subtree becomes its right subtree and vice versa. This transformation should be applied recursively to all nodes in the tree.

The function should modify the tree in-place and return the root of the mirrored tree.

Input & Output

Example 1 — Basic Binary Tree

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

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

💡 Note: Mirror the tree by swapping left/right children at every node. Root 4's children swap from [2,7] to [7,2], node 2's children swap from [1,3] to [3,1], node 7's children swap from [6,9] to [9,6].

Example 2 — Single Node Tree

$ Input: root = [1]

› Output: [1]

💡 Note: A single node has no children to swap, so the tree remains unchanged.

Example 3 — Empty Tree

$ Input: root = []

› Output: []

💡 Note: An empty tree (null root) remains empty after mirroring.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The key insight is that mirroring a binary tree means swapping left and right children at every node recursively. The optimal approach uses in-place DFS to swap children during traversal, avoiding the need to create a new tree. Time: O(n), Space: O(h)

Common Approaches

✓ In-Place DFS Mirror

⏱️ Time: O(n) Space: O(h)

Use depth-first search to visit each node and swap its left and right children directly, modifying the original tree structure without creating new nodes.

Iterative BFS Mirror

⏱️ Time: O(n) Space: O(w)

Process the tree level by level using a queue. For each node, swap its left and right children, then add the children to the queue for processing.

Recursive Copy Mirror

⏱️ Time: O(n) Space: O(n)

Traverse the original tree and build a completely new mirrored tree by creating new nodes and swapping their left/right children during construction.

In-Place DFS Mirror — Algorithm Steps

Step 1: If current node is null, return null
Step 2: Swap current node's left and right children
Step 3: Recursively mirror the left subtree
Step 4: Recursively mirror the right subtree

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Tree

Start with input tree structure

Recursive Swapping

At each node, swap left and right children

Mirrored Result

Same tree, children swapped at every level

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* solution(struct TreeNode* root) {
    if (!root) return NULL;
    
    // Swap left and right children
    struct TreeNode* temp = root->left;
    root->left = root->right;
    root->right = temp;
    
    // Recursively mirror subtrees
    solution(root->left);
    solution(root->right);
    
    return root;
}

void printArray(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    // Simple level order print
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    printf("[");
    int first = 1;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (!first) printf(",");
        first = 0;
        
        if (node) {
            printf("%d", node->val);
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            printf("null");
        }
    }
    
    printf("]\n");
}

struct TreeNode* buildTree() {
    // Simple implementation for basic test case
    struct TreeNode* root = createNode(4);
    root->left = createNode(2);
    root->right = createNode(7);
    root->left->left = createNode(1);
    root->left->right = createNode(3);
    root->right->left = createNode(6);
    root->right->right = createNode(9);
    return root;
}

int main() {
    // Simplified for basic functionality
    struct TreeNode* root = buildTree();
    struct TreeNode* result = solution(root);
    printArray(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each of n nodes exactly once to swap children

✓ Linear Growth

Space Complexity

O(h)

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

✓ Linear Space

77.7K Views

Medium Frequency

~15 min Avg. Time

2.1K 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

Binary Tree Mirror - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

In-Place DFS Mirror — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler