Split BST

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

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

✓ Brute Force (Inorder + Rebuild)

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

First perform an inorder traversal to collect all values, separate them based on the target, then construct two new BSTs from the separated values. This approach completely rebuilds the trees.

Optimal Recursive Split

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

Use the BST property to recursively determine where to split the tree. At each node, decide whether it belongs in the left or right result tree, and recursively split its subtrees accordingly. This preserves the 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>
#include <string.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;
}

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;
    }
    
    if (root->val <= target) {
        // Current node goes to left tree
        struct TreeNode* leftRoot = root;
        // Recursively split right subtree
        int subSize;
        struct TreeNode** subResult = splitBST(root->right, target, &subSize);
        // Attach left part of right subtree to current node
        leftRoot->right = subResult[0];
        result[0] = leftRoot;
        result[1] = subResult[1];
        free(subResult);
        return result;
    } else {
        // Current node goes to right tree
        struct TreeNode* rightRoot = root;
        // Recursively split left subtree
        int subSize;
        struct TreeNode** subResult = splitBST(root->left, target, &subSize);
        // Attach right part of left subtree to current node
        rightRoot->left = subResult[1];
        result[0] = subResult[0];
        result[1] = rightRoot;
        free(subResult);
        return result;
    }
}

struct TreeNode* buildTree(char arr[][20], int size) {
    if (size == 0 || strcmp(arr[0], "null") == 0) {
        return NULL;
    }
    
    struct TreeNode** nodes = (struct TreeNode**)malloc(size * sizeof(struct TreeNode*));
    for (int i = 0; i < size; i++) {
        if (strcmp(arr[i], "null") == 0) {
            nodes[i] = NULL;
        } else {
            nodes[i] = createNode(atoi(arr[i]));
        }
    }
    
    for (int i = 0; i < size; i++) {
        if (nodes[i] != NULL) {
            int leftIdx = 2 * i + 1;
            int rightIdx = 2 * i + 2;
            if (leftIdx < size) {
                nodes[i]->left = nodes[leftIdx];
            }
            if (rightIdx < size) {
                nodes[i]->right = nodes[rightIdx];
            }
        }
    }
    
    struct TreeNode* root = nodes[0];
    free(nodes);
    return root;
}

void treeToArray(struct TreeNode* root, char result[][20], int* size) {
    if (!root) {
        *size = 0;
        return;
    }
    
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    *size = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        if (node) {
            sprintf(result[(*size)++], "%d", node->val);
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            strcpy(result[(*size)++], "null");
        }
    }
    
    // Remove trailing nulls
    while (*size > 0 && strcmp(result[*size - 1], "null") == 0) {
        (*size)--;
    }
}

void formatArray(char arr[][20], int size, char* output) {
    if (size == 0) {
        strcpy(output, "[]");
        return;
    }
    strcpy(output, "[");
    for (int i = 0; i < size; i++) {
        if (i > 0) strcat(output, ",");
        strcat(output, arr[i]);
    }
    strcat(output, "]");
}

void parseArray(const char* str, int* arr, 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;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char treeInput[1000];
    int target;
    
    fgets(treeInput, sizeof(treeInput), stdin);
    scanf("%d", &target);
    
    // Remove newline
    treeInput[strcspn(treeInput, "\n")] = 0;
    
    char arr[100][20];
    int arrSize = 0;
    
    if (strlen(treeInput) > 0) {
        char* token = strtok(treeInput, ",");
        while (token != NULL) {
            strcpy(arr[arrSize++], token);
            token = strtok(NULL, ",");
        }
    }
    
    struct TreeNode* root = buildTree(arr, arrSize);
    int returnSize;
    struct TreeNode** result = splitBST(root, target, &returnSize);
    
    char leftArr[100][20], rightArr[100][20];
    int leftSize, rightSize;
    
    treeToArray(result[0], leftArr, &leftSize);
    treeToArray(result[1], rightArr, &rightSize);
    
    char leftFormatted[1000], rightFormatted[1000];
    formatArray(leftArr, leftSize, leftFormatted);
    formatArray(rightArr, rightSize, rightFormatted);
    
    printf("[%s,%s]\n", leftFormatted, rightFormatted);
    
    free(result);
    return 0;
}

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