Trim a Binary Search Tree

Trim a Binary Search Tree - Problem

Given the root of a binary search tree and the lowest and highest boundaries as low and high, trim the tree so that all its elements lie in [low, high].

Trimming the tree should not change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant).

It can be proven that there is a unique answer. Return the root of the trimmed binary search tree. Note that the root may change depending on the given bounds.

Input & Output

Example 1 — Basic Trimming

$ Input: root = [1,0,2,null,null,1,3], low = 1, high = 2

› Output: [1,null,2,null,1]

💡 Note: Remove node 0 (< 1) and node 3 (> 2). Node 0's right subtree becomes new left of root 1.

Example 2 — Root Changes

$ Input: root = [3,0,4,null,2,null,null,1], low = 1, high = 3

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

💡 Note: Remove node 0 and 4. The tree structure is preserved with root 3, left subtree [2,1].

Example 3 — All Nodes Valid

$ Input: root = [1,null,2], low = 1, high = 2

› Output: [1,null,2]

💡 Note: All nodes are within [1,2] range, so no trimming needed.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
0 ≤ Node.val ≤ 10⁴
The value of each node in the tree is unique
root is guaranteed to be a valid binary search tree
0 ≤ low ≤ high ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 M Microsoft 8

The key insight is to leverage the BST property for efficient trimming: if a node's value is less than low, the entire left subtree can be discarded and we only need the trimmed right subtree. Similarly, if greater than high, we only need the trimmed left subtree. Best approach is DFS recursive trimming with Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force - Collect and Rebuild

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

First traverse the entire tree to collect all node values that fall within [low, high]. Then construct a new balanced BST from these collected values.

DFS Recursive Trimming

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

Use depth-first search with BST property: if current node is less than low, the trimmed tree must be in right subtree; if greater than high, it must be in left subtree. Otherwise, recursively trim both subtrees.

Brute Force - Collect and Rebuild — Algorithm Steps

Step 1: Traverse tree and collect values in [low, high]
Step 2: Sort collected values
Step 3: Recursively build balanced BST from sorted array

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Values

Traverse tree and collect values in range [1,3]

Sort Values

Sort collected values: [1,2,3]

Rebuild BST

Create balanced BST from sorted array

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* trimTree(struct TreeNode* node, int low, int high) {
    if (!node) return NULL;
    
    if (node->val < low) {
        return trimTree(node->right, low, high);
    } else if (node->val > high) {
        return trimTree(node->left, low, high);
    } else {
        node->left = trimTree(node->left, low, high);
        node->right = trimTree(node->right, low, high);
        return node;
    }
}

static int data[10000];
static int isNull[10000];
static struct TreeNode* queue[10000];
static int queueValues[10000];
static int queueIsNull[10000];

void parseArray(const char* str, 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;
        
        if (strncmp(p, "null", 4) == 0) {
            isNull[*size] = 1;
            data[*size] = 0;
            p += 4;
        } else {
            isNull[*size] = 0;
            data[*size] = (int)strtol(p, (char**)&p, 10);
        }
        (*size)++;
    }
}

struct TreeNode* deserialize(int size) {
    if (size == 0 || isNull[0]) return NULL;
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = data[0];
    root->left = root->right = NULL;
    
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        if (node) {
            if (i < size && !isNull[i]) {
                node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                node->left->val = data[i];
                node->left->left = node->left->right = NULL;
                queue[rear++] = node->left;
            } else {
                queue[rear++] = NULL;
            }
            i++;
            if (i < size && !isNull[i]) {
                node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                node->right->val = data[i];
                node->right->left = node->right->right = NULL;
                queue[rear++] = node->right;
            } else {
                queue[rear++] = NULL;
            }
            i++;
        }
    }
    
    return root;
}

char* serialize(struct TreeNode* node) {
    char* result = (char*)malloc(10000);
    strcpy(result, "[");
    
    if (!node) {
        strcat(result, "]");
        return result;
    }
    
    int front = 0, rear = 0, resultSize = 0;
    
    queue[rear++] = node;
    
    while (front < rear) {
        struct TreeNode* current = queue[front++];
        if (current) {
            queueValues[resultSize] = current->val;
            queueIsNull[resultSize] = 0;
            queue[rear++] = current->left;
            queue[rear++] = current->right;
        } else {
            queueValues[resultSize] = 0;
            queueIsNull[resultSize] = 1;
        }
        resultSize++;
    }
    
    // Remove trailing nulls
    while (resultSize > 0 && queueIsNull[resultSize-1]) {
        resultSize--;
    }
    
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) strcat(result, ",");
        if (queueIsNull[i]) {
            strcat(result, "null");
        } else {
            char temp[20];
            sprintf(temp, "%d", queueValues[i]);
            strcat(result, temp);
        }
    }
    
    strcat(result, "]");
    
    return result;
}

char* solution(struct TreeNode* root, int low, int high) {
    struct TreeNode* trimmedRoot = trimTree(root, low, high);
    return serialize(trimmedRoot);
}

int main() {
    char rootStr[10000];
    int low, high;
    fgets(rootStr, sizeof(rootStr), stdin);
    scanf("%d", &low);
    scanf("%d", &high);
    
    int size;
    parseArray(rootStr, &size);
    
    struct TreeNode* root = deserialize(size);
    char* result = solution(root, low, high);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to traverse and collect values, O(n log n) to sort, O(n) to rebuild tree

⚡ Linearithmic

Space Complexity

O(n)

Extra array to store collected values plus O(h) recursion stack

⚡ Linearithmic Space

156.2K 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

Brute Force - Collect and Rebuild — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler