Increasing Order Search Tree - Practice Coding Problems

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

Understanding the Visualization

Identify Traversal Order

In-order traversal of BST gives us the sorted sequence we need

Use Previous Pointer

Maintain reference to previously processed node to build chain

Modify During Traversal

Clear left pointers and connect right pointers as we visit nodes

Return New Root

The leftmost node becomes root of our right-skewed tree

Key Takeaway

🎯 Key Insight: In-order traversal of a BST naturally gives us the sorted sequence we need. Instead of collecting values and rebuilding, we can modify the tree structure during traversal using a previous node pointer, achieving optimal space complexity.

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

Approach	Time	Space	Notes
✓ Collect and Rebuild	O(n)	O(n)	Extract all values via in-order traversal, then build new tree
In-Order Traversal with Rebuilding (Optimal)	O(n)	O(h)	Modify tree structure during in-order traversal using a previous node pointer

Collect and Rebuild — Algorithm Steps

Perform in-order traversal to collect all values in array
Create new nodes for each value in order
Link each new node's right pointer to the next node
Return the first node as new root

Visualization

Tap to expand

Step-by-Step Walkthrough

In-order Traversal

Visit nodes left→root→right to collect values [1,5,7,8]

Build Array

Store all values in order in an array

Create New Nodes

Build new tree with right-only connections

Link Nodes

Connect each node to the next via right pointer

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void inorder(struct TreeNode* node, int* values, int* size) {
    if (!node) return;
    inorder(node->left, values, size);
    values[(*size)++] = node->val;
    inorder(node->right, values, size);
}

struct TreeNode* increasingBST(struct TreeNode* root) {
    // Collect all values in in-order
    int values[1000]; // Assuming max 1000 nodes
    int size = 0;
    inorder(root, values, &size);
    
    // Build new right-skewed tree
    if (size == 0) return NULL;
    
    struct TreeNode* newRoot = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newRoot->val = values[0];
    newRoot->left = NULL;
    newRoot->right = NULL;
    
    struct TreeNode* current = newRoot;
    
    for (int i = 1; i < size; i++) {
        current->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        current = current->right;
        current->val = values[i];
        current->left = NULL;
        current->right = NULL;
    }
    
    return newRoot;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

One pass to collect values O(n) + one pass to build tree O(n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

O(n) for values array + O(n) for new nodes + O(h) recursion stack

⚡ Linearithmic 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Collect and Rebuild — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler