Split BST - Practice Coding Problems

Split BST - Problem

Imagine you have a Binary Search Tree (BST) and need to split it into two separate trees based on a target value. This is like organizing a library where you want to separate books into two sections: one for books with ID numbers ≤ target, and another for books with ID numbers > target.

Given the root of a BST and an integer target, you need to split the tree into two subtrees:

Left subtree: Contains all nodes with values ≤ target
Right subtree: Contains all nodes with values > target

The challenge is to preserve the original tree structure as much as possible. If a parent-child relationship existed in the original tree and both nodes end up in the same subtree, that relationship should be maintained.

Important: The target value might not exist in the tree, but you still need to perform the split based on that value.

Return an array [leftRoot, rightRoot] where leftRoot is the root of the subtree with values ≤ target, and rightRoot is the root of the subtree with values > target.

Input & Output

example_1.py — Basic Split

$ Input: root = [4,2,6,1,3,5,8], target = 4

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

💡 Note: Node 4 and all nodes ≤ 4 (1,2,3,4) go to left tree. Nodes > 4 (6,8) go to right tree. Node 5 gets attached to the left tree as it's ≤ target.

example_2.py — Target Not in Tree

$ Input: root = [4,2,6,1,3,5,7], target = 2

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

💡 Note: Even though target 2 exists, we split at that value. Nodes ≤ 2 (1,2) form left tree, nodes > 2 (3,4,5,6,7) form right tree.

example_3.py — Single Node

$ Input: root = [1], target = 1

› Output: [[1], []]

💡 Note: Single node with value 1, target is 1. Since 1 ≤ 1, the node goes to the left tree, right tree is empty.

Constraints

The number of nodes in the tree is in the range [0, 100]
0 ≤ Node.val ≤ 100
0 ≤ target ≤ 100
The tree is a valid BST (left subtree values < root < right subtree values)

Visualization

Tap to expand

Understanding the Visualization

Identify Split Point

Compare current node value with target to determine which result tree it belongs to

Recursive Decision

If node ≤ target, it goes left and we need to split its right subtree

Connect Results

Properly connect the recursive split results to maintain BST properties

Preserve Structure

Original parent-child relationships are maintained within each result tree

Key Takeaway

🎯 Key Insight: Use recursion to make split decisions at each node, leveraging BST properties to determine which subtree needs further processing while preserving the original tree structure.

Asked in

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

The optimal recursive approach leverages BST properties to split the tree in O(n) time while preserving the original structure. At each node, we decide which result tree it belongs to based on the target comparison, then recursively split the appropriate subtree and connect the results properly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Inorder + Rebuild)	O(n²)	O(n)	Traverse tree, collect values, then rebuild two new BSTs
Optimal Recursive Split	O(n)	O(h)	Recursively split the tree while preserving original structure

Brute Force (Inorder + Rebuild) — Algorithm Steps

Perform inorder traversal to collect all node values
Separate values into two arrays based on target
Build new BST from values ≤ target
Build new BST from values > target
Return roots of both new trees

Visualization

Tap to expand

Step-by-Step Walkthrough

Traverse Original

Perform inorder traversal to collect all values

Separate Values

Split values based on target into two arrays

Rebuild Trees

Construct two new BSTs from the separated values

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = node->right = NULL;
    return node;
}

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* buildBST(int* values, int start, int end) {
    if (start > end) return NULL;
    int mid = start + (end - start) / 2;
    struct TreeNode* root = createNode(values[mid]);
    root->left = buildBST(values, start, mid - 1);
    root->right = buildBST(values, mid + 1, end);
    return root;
}

struct TreeNode** splitBST(struct TreeNode* root, int target, int* returnSize) {
    *returnSize = 2;
    struct TreeNode** result = (struct TreeNode**)malloc(2 * sizeof(struct TreeNode*));
    
    if (!root) {
        result[0] = result[1] = NULL;
        return result;
    }
    
    int values[1000];
    int size = 0;
    inorder(root, values, &size);
    
    int leftVals[1000], rightVals[1000];
    int leftSize = 0, rightSize = 0;
    
    for (int i = 0; i < size; i++) {
        if (values[i] <= target) {
            leftVals[leftSize++] = values[i];
        } else {
            rightVals[rightSize++] = values[i];
        }
    }
    
    result[0] = leftSize > 0 ? buildBST(leftVals, 0, leftSize - 1) : NULL;
    result[1] = rightSize > 0 ? buildBST(rightVals, 0, rightSize - 1) : NULL;
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for traversal + O(n²) worst case for rebuilding unbalanced trees

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) for storing values + O(n) for recursion stack

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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 (Inorder + Rebuild) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler