Codestin Search App

Trim a Binary Search Tree - Problem

Given the root of a binary search tree and two boundary values low and high, your task is to trim the tree so that all remaining nodes have values within the range [low, high] (inclusive).

The key challenge is that trimming must preserve the BST structure - any node's descendants must remain as descendants in the trimmed tree. This means you can't simply remove nodes arbitrarily; you need to carefully reconstruct the tree while maintaining BST properties.

Important: The root of the trimmed tree might be different from the original root, depending on whether the original root's value falls within the given bounds.

Example: If you have a BST with nodes [1, 0, 2] and bounds [1, 2], the trimmed tree should only contain nodes with values 1 and 2, maintaining their parent-child relationships.

Input & Output

example_1.py — Basic Trimming

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

› Output: [1,null,2]

💡 Note: Node 0 is outside the range [1,2], so it gets removed. The result is a tree with root 1 and right child 2.

example_2.py — Complex Trimming

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

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

💡 Note: Nodes 0 and 4 are outside [1,3]. After trimming, node 2 becomes the left child of 3, and node 1 becomes the left child of 2.

example_3.py — Edge Case - Single Node

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

› Output: [1]

💡 Note: Single node with value 1 is within range [1,2], so no trimming needed.

Visualization

Tap to expand

Understanding the Visualization

Inspect Current Branch

Look at the current branch's fruit size

Make Smart Decision

If too small, only check right side (larger fruits). If too large, only check left side (smaller fruits)

Keep Good Branches

If the fruit is just right, keep this branch and check both sides for more good fruits

Natural Structure

The tree maintains its natural organization throughout the pruning process

Key Takeaway

🎯 Key Insight: BST properties let us make smart pruning decisions - we can eliminate entire subtrees without checking every branch, just like knowing that all fruits on the left are smaller than the current branch!

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we visit each node exactly once to determine if it should be kept or discarded

✓ Linear Growth

Space Complexity

O(h)

Space used by recursion stack, where h is height of tree. O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Space

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⁴

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses recursive depth-first traversal leveraging BST properties. For each node: if value < low, return trimmed right subtree; if value > high, return trimmed left subtree; otherwise keep node and trim both subtrees. This achieves O(n) time and O(h) space complexity while preserving tree structure.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Trimming (Optimal)	O(n)	O(h)	Use BST properties to recursively trim nodes while preserving structure
Brute Force (Collect and Rebuild)	O(n)	O(n)	Collect all valid values in range, then rebuild BST from scratch

Recursive Trimming (Optimal) — Algorithm Steps

If current node is null, return null
If node value < low, recursively trim right subtree (left subtree is useless)
If node value > high, recursively trim left subtree (right subtree is useless)
If node value is in [low, high], trim both subtrees and return current node

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Root

If root value < low, go right only. If > high, go left only. Otherwise, keep and recurse both sides

Recursive Calls

Apply same logic recursively to each subtree

Build Result

Return the trimmed tree with preserved BST structure

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;
};

struct TreeNode* trimBST(struct TreeNode* root, int low, int high) {
    if (!root) {
        return NULL;
    }
    
    // If current node is smaller than low bound,
    // then its left subtree is also smaller, so we only need right subtree
    if (root->val < low) {
        return trimBST(root->right, low, high);
    }
    
    // If current node is larger than high bound,
    // then its right subtree is also larger, so we only need left subtree
    if (root->val > high) {
        return trimBST(root->left, low, high);
    }
    
    // Current node is in valid range, so trim both subtrees
    root->left = trimBST(root->left, low, high);
    root->right = trimBST(root->right, low, high);
    
    return root;
}

int main() {
    // Parse input and create tree
    printf("Tree trimmed successfully\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we visit each node exactly once to determine if it should be kept or discarded

✓ Linear Growth

Space Complexity

O(h)

Space used by recursion stack, where h is height of tree. O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Space

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⁴

68.0K Views

Medium-High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Trimming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler