Increasing Order Search Tree

Increasing Order Search Tree - Problem

Transform a Binary Search Tree into a Skewed Right Tree

Given the root of a binary search tree, your task is to rearrange the tree structure so that it follows these rules:

🎯 Goal: Create a "skewed" tree where every node only has a right child
📋 Requirements:
• The leftmost node becomes the new root
• Every node has no left child
• Every node has at most one right child
• The tree maintains in-order traversal sequence

Example: If your BST in-order is [1, 5, 3, 6, 2, 8, 7], the result should be a right-skewed tree: 1 → 5 → 3 → 6 → 2 → 8 → 7

💡 Key Insight: Since BST in-order traversal gives sorted sequence, we need to create a linear right-only chain in that exact order!

Input & Output

example_1.py — Basic BST

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

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

💡 Note: The in-order traversal of the original BST gives us [1,2,3,4,5,6,7,8,9]. We rearrange this into a right-skewed tree where each node only has a right child, maintaining the sorted order.

example_2.py — Simple Tree

$ Input: root = [5,1,7]

› Output: [1,null,5,null,7]

💡 Note: In-order traversal gives [1,5,7]. The result is a chain: 1→5→7 where 1 is the root, 1.right=5, 5.right=7, and all left pointers are null.

example_3.py — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: A single node tree remains unchanged since it already has no left children and satisfies the constraint.

Constraints

The number of nodes in the given tree will be in the range [1, 100]
0 ≤ Node.val ≤ 1000
The tree is guaranteed to be a valid binary search tree
Follow-up: Can you solve this in O(h) space where h is the height of the tree?

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 35 ⊞ Microsoft 28 f Meta 22

The optimal approach uses in-order traversal with real-time reconstruction. During traversal, we maintain a previous node pointer to build the right-skewed chain on-the-fly. This achieves O(n) time and O(h) space complexity while reusing existing nodes instead of creating new ones. Key insight: since in-order traversal of BST gives sorted order, we can directly build our result during the traversal process.

Common Approaches

✓ Memoization

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

Collect and Rebuild

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

This approach first performs an in-order traversal to collect all node values in sorted order, then constructs a completely new right-skewed tree using these values. While straightforward, it uses extra space for both the value array and new nodes.

In-Order Traversal with Rebuilding (Optimal)

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

This optimal approach performs in-order traversal while simultaneously reconstructing the tree. We maintain a 'previous' node pointer and connect each visited node to form the right-skewed chain. This reuses existing nodes instead of creating new ones.

Optimized

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

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int* memo;
static int* arr;
static int d, n;

int canJump(int i, int j) {
    if (abs(i - j) > d || arr[i] <= arr[j]) {
        return 0;
    }
    int start = i < j ? i : j;
    int end = i > j ? i : j;
    for (int k = start + 1; k < end; k++) {
        if (arr[k] >= arr[i]) {
            return 0;
        }
    }
    return 1;
}

int dfs(int pos) {
    if (memo[pos] != -1) {
        return memo[pos];
    }
    
    int maxPath = 1;
    int startPos = pos - d > 0 ? pos - d : 0;
    int endPos = pos + d < n - 1 ? pos + d : n - 1;
    
    for (int nextPos = startPos; nextPos <= endPos; nextPos++) {
        if (nextPos != pos && canJump(pos, nextPos)) {
            int pathLen = 1 + dfs(nextPos);
            if (pathLen > maxPath) {
                maxPath = pathLen;
            }
        }
    }
    
    memo[pos] = maxPath;
    return maxPath;
}

int solution(int* inputArr, int inputN, int inputD) {
    arr = inputArr;
    n = inputN;
    d = inputD;
    memo = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        memo[i] = -1;
    }
    
    int result = 1;
    for (int i = 0; i < n; i++) {
        int pathLen = dfs(i);
        if (pathLen > result) {
            result = pathLen;
        }
    }
    
    free(memo);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int n = 0;
    
    // Skip the opening bracket
    char* ptr = line + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL && n < 1000) {
        // Remove any whitespace
        while (*token == ' ') token++;
        if (*token != '\0' && *token != ']' && *token != '\n') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, ",]");
    }
    
    int d;
    scanf("%d", &d);
    
    int result = solution(arr, n, d);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

98.5K Views

Medium Frequency

~15 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