Change the Root of a Binary Tree

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

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

✓ Binary Search

⏱️ Time: N/A Space: N/A

Brute Force (Path Finding + Reconstruction)

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

This approach first finds the path from root to the target leaf, then reconstructs the entire tree by creating new nodes and reassigning relationships. It's straightforward but inefficient as it processes nodes multiple times.

One-Pass DFS Traversal (Optimal)

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

The optimal approach uses a single DFS traversal from the leaf node upward to the root, flipping parent-child relationships along the way. This eliminates the need for path storage and multiple traversals, making it both time and space efficient.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int findFirst(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    int first = -1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            first = mid;
            right = mid - 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return first;
}

int findLast(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    int last = -1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            last = mid;
            left = mid + 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return last;
}

bool solution(int* nums, int numsSize, int target) {
    int first = findFirst(nums, numsSize, target);
    if (first == -1) return false;
    
    int last = findLast(nums, numsSize, target);
    int count = last - first + 1;
    return count > numsSize / 2;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    
    // Find the opening bracket
    char* start = strchr(line, '[');
    if (start) {
        start++; // Move past the '['
        char* token = strtok(start, ",]");
        while (token != NULL && numsSize < 1000) {
            // Skip whitespace
            while (*token == ' ') token++;
            if (*token != '\0') {
                nums[numsSize++] = atoi(token);
            }
            token = strtok(NULL, ",]");
        }
    }
    
    int target;
    scanf("%d", &target);
    
    bool result = solution(nums, numsSize, target);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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