Change the Root of a Binary Tree - Practice Coding Problems

Change the Root of a Binary Tree - Problem

Change the Root of a Binary Tree is a fascinating tree transformation problem that challenges you to restructure an entire binary tree by making any leaf node the new root.

Given the root of a binary tree and a specific leaf node, you need to reroot the tree so that the leaf becomes the new root. This involves reversing the parent-child relationships along the path from the leaf to the original root.

The transformation follows specific rules:
• For each node on the path from leaf to root (excluding the original root):
• If the current node has a left child, that child becomes its right child
• The current node's original parent becomes its left child
• The original parent's pointer to current node becomes null

Important: You must correctly update all Node.parent pointers in the final tree structure.

Input & Output

example_1.py — Simple Tree Flip

$ Input: root = [3,5,1,6,2,0,8,null,null,7,4], leaf = Node(7)

› Output: New tree with 7 as root: [7,2,null,5,4,3,null,6,null,1,null,null,null,0,8]

💡 Note: The leaf node 7 becomes the new root. Its original parent 2 becomes its left child, and the path continues flipping relationships up to the original root 3.

example_2.py — Deep Leaf

$ Input: root = [1,2,3,4,5], leaf = Node(4)

› Output: New tree with 4 as root: [4,2,null,1,null,null,3,null,5]

💡 Note: Node 4 (originally leftmost leaf) becomes root, with 2 as left child and 1 as grandchild, while 3 and 5 remain in their relative positions.

example_3.py — Single Child Path

$ Input: root = [1,2,null,3], leaf = Node(3)

› Output: New tree with 3 as root: [3,2,null,1]

💡 Note: Simple linear transformation where 3 becomes root, 2 becomes its left child, and 1 becomes the left child of 2.

Constraints

The number of nodes in the tree is in the range [1, 100]
1 ≤ Node.val ≤ 100
All Node.val are unique
leaf exist in the tree and is a leaf node
The tree has proper parent pointers set up initially

Visualization

Tap to expand

Understanding the Visualization

Identify the Path

Find the path from the target leaf up to the current root - this is our transformation path

Start from Leaf

Begin at the leaf node that will become our new root

Flip Relationships

For each step upward, make the parent become the left child of the current node

Preserve Structure

Move any existing left child to the right position to maintain tree structure

Update Pointers

Ensure all parent pointers are correctly updated throughout the transformation

Key Takeaway

🎯 Key Insight: Only the nodes on the path from leaf to root need to be modified. The rest of the tree structure remains intact, making this an efficient O(h) operation where h is the path length.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal solution uses a one-pass traversal from the leaf upward to the root, flipping parent-child relationships along the path. The key insight is to start at the target leaf and work upward, making each node's parent become its left child while moving any existing left child to the right position. This approach runs in O(h) time where h is the height of the path, and uses O(1) space, making it highly efficient for tree restructuring problems.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass DFS Traversal (Optimal)	O(h)	O(1)	Traverse from leaf to root, flipping relationships in a single pass
Brute Force (Path Finding + Reconstruction)	O(n²)	O(n)	Find path to leaf, then reconstruct entire tree structure

One-Pass DFS Traversal (Optimal) — Algorithm Steps

Start from the target leaf node
Traverse upward using parent pointers
For each node, flip its relationship with its parent
Handle left child repositioning as we go
Update parent pointers correctly
Return the leaf as the new root

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Leaf

Begin at target leaf node, this will be our new root

Move Left Child

If current node has left child, move it to right position

Flip Parent

Make current node's parent become its left child

Update Pointers

Fix all parent pointers for the flipped relationship

Continue Upward

Repeat process moving up toward original root

Code -

solution.c — C

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

struct Node {
    int val;
    struct Node* left;
    struct Node* right;
    struct Node* parent;
};

struct Node* flipBinaryTree(struct Node* root, struct Node* leaf) {
    if (!root || !leaf || root == leaf) {
        return leaf;
    }
    
    struct Node* current = leaf;
    struct Node* newRoot = leaf;
    
    while (current->parent) {
        struct Node* parent = current->parent;
        struct Node* grandparent = parent->parent;
        
        // Remove current from parent's children
        if (parent->left == current) {
            parent->left = NULL;
        } else {
            parent->right = NULL;
        }
        
        // If current had a left child, move it to right
        if (current->left) {
            current->right = current->left;
        }
        
        // Make parent the left child of current
        current->left = parent;
        current->parent = grandparent;
        parent->parent = current;
        
        // Move up the tree
        current = grandparent;
    }
    
    newRoot->parent = NULL;
    return newRoot;
}

Time & Space Complexity

Time Complexity

⏱️

O(h)

Where h is height from leaf to root - only processes nodes on the path

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for temporary variables

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

One-Pass DFS Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler