Binary Tree Upside Down - Practice Coding Problems

Binary Tree Upside Down - Problem

Imagine you have a binary tree that needs to be completely flipped upside down! This isn't just a simple rotation - it's a systematic transformation where each level undergoes a specific rearrangement.

Given the root of a binary tree, you need to turn the entire tree upside down and return the new root. The transformation follows these rules for each node:

The original left child becomes the new root
The original root becomes the new right child
The original right child becomes the new left child

This process is applied level by level throughout the tree. The problem guarantees that every right node has a corresponding left sibling (same parent) and that right nodes have no children, making this transformation always possible.

Example: If you have a tree like 1-2-3, after flipping it becomes a completely different structure where the leftmost bottom node becomes the new root!

Input & Output

example_1.py — Basic Tree

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

› Output: [4,5,2,null,null,3,1]

💡 Note: The original tree has root 1 with children 2,3. Node 2 has children 4,5. After flipping upside down, node 4 (leftmost leaf) becomes the new root. Node 2 becomes 4's right child, and 5 becomes 4's left child. This pattern continues up the tree.

example_2.py — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: A single node tree remains unchanged when flipped upside down since there are no children to rearrange.

example_3.py — Empty Tree

$ Input: root = []

› Output: []

💡 Note: An empty tree (null root) remains empty after the upside-down transformation.

Constraints

The number of nodes in the tree is in the range [0, 1000]
-1000 ≤ Node.val ≤ 1000
Every right node has a sibling (left node with same parent) and no children
The tree structure guarantees a valid upside-down transformation is possible

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

The leftmost leaf becomes the new root of the entire tree

Process Bottom-Up

Start from the deepest level and work your way up, transforming relationships

Apply Transformation Rules

For each node: left child → new parent, original node → right child, right sibling → left child

Return New Root

The transformation cascades up, returning the new root of the upside-down tree

Key Takeaway

🎯 Key Insight: The upside-down transformation follows a consistent pattern where each left child becomes the new parent, original parents become right children, and right siblings become left children. Process recursively from the leftmost path!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses bottom-up recursion to transform the tree in O(n) time and O(h) space. The key insight is to process the leftmost path first, then rearrange parent-child relationships: left child becomes new root, original root becomes right child, and original right child becomes left child. This elegant solution avoids creating new nodes and works with the existing tree structure.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative Level-by-Level Transformation	O(n²)	O(n)	Process each level iteratively, storing intermediate states and rebuilding connections

Iterative Level-by-Level Transformation — Algorithm Steps

Use level-order traversal to identify all nodes at each level
For each level, store the current parent-child relationships
Transform relationships according to upside-down rules
Rebuild connections level by level from bottom to top

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Levels

Use BFS to identify and store all nodes at each level

Process Each Level

Transform parent-child relationships level by level

Track Relationships

Maintain queues to track old and new relationships

Rebuild Tree

Construct the final upside-down tree structure

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.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* transform(struct TreeNode* node) {
    if (node == NULL || node->left == NULL) {
        return node;
    }
    
    struct TreeNode* newRoot = transform(node->left);
    
    node->left->left = node->right;
    node->left->right = node;
    
    node->left = NULL;
    node->right = NULL;
    
    return newRoot;
}

struct TreeNode* upsideDownBinaryTree(struct TreeNode* root) {
    if (root == NULL || root->left == NULL) {
        return root;
    }
    
    return transform(root);
}

int main() {
    struct TreeNode* root = createNode(1);
    struct TreeNode* result = upsideDownBinaryTree(root);
    
    if (result != NULL) {
        printf("[%d]\n", result->val);
    } else {
        printf("[]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for each level processing across O(n) levels in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Space for queues and temporary relationship storage

⚡ Linearithmic Space

78.2K Views

Medium Frequency

~18 min Avg. Time

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

Iterative Level-by-Level Transformation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler