Merge BSTs to Create Single BST

Merge BSTs to Create Single BST - Problem

You are given n BST (binary search tree) root nodes for n separate BSTs stored in an array trees (0-indexed). Each BST in trees has at most 3 nodes, and no two roots have the same value.

In one operation, you can:

Select two distinct indices i and j such that the value stored at one of the leaves of trees[i] is equal to the root value of trees[j].
Replace the leaf node in trees[i] with trees[j].
Remove trees[j] from trees.

Return the root of the resulting BST if it is possible to form a valid BST after performing n - 1 operations, or null if it is impossible to create a valid BST.

A BST (binary search tree) is a binary tree where each node satisfies the following property:

Every node in the node's left subtree has a value strictly less than the node's value.
Every node in the node's right subtree has a value strictly greater than the node's value.

A leaf is a node that has no children.

Input & Output

Example 1 — Multiple Small BSTs

$ Input: trees = [[2,1],[3,2,5],[5,4]]

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

💡 Note: Tree with root 3 has leaves [2,5]. We can merge tree with root 2 into leaf 2, and tree with root 5 into leaf 5, creating a valid BST.

Example 2 — No Valid Merge

$ Input: trees = [[5,3,8],[3,2,6]]

› Output: null

💡 Note: Cannot create a valid BST because no valid merging strategy exists that maintains BST properties.

Example 3 — Single Tree

$ Input: trees = [[1,null,3]]

› Output: [1,null,3]

💡 Note: Only one tree provided, so return it as is since it's already a valid BST.

Constraints

n == trees.length
1 ≤ n ≤ 5×10⁴
Each tree in the input is a BST with at most 3 nodes
No two roots have the same value

Visualization

Tap to expand

Asked in

A Amazon 45 G Google 38 M Microsoft 32 F Facebook 28

The key insight is finding the unique root that cannot be a leaf in another tree. The optimal approach uses strategic root identification followed by DFS merging. Time: O(n × 2^n), Space: O(n²)

Common Approaches

✓ Brute Force DFS with Backtracking

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

For each tree, try using it as the main root and attempt to merge all other trees into it by matching leaf values with root values. Use backtracking to explore all possibilities.

DFS with Strategic Root Finding

⏱️ Time: O(n × 2^n) Space: O(n²)

First identify which tree root can never be a leaf in another tree - this must be our final root. Then use DFS to merge other trees by matching leaf values with root values.

Brute Force DFS with Backtracking — Algorithm Steps

Step 1: Try each tree as potential main root
Step 2: For each leaf value, find matching root value
Step 3: Recursively merge and validate BST properties
Step 4: Backtrack if merge fails

Visualization

Tap to expand

Step-by-Step Walkthrough

Try First Tree as Root

Start with trees[0] and attempt to merge others

Match Leaf to Root Values

Find leaf values that match root values of other trees

Validate BST Property

Check if merged result maintains BST constraints

Backtrack if Invalid

Try next combination if current merge fails

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <limits.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 = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* copyTree(struct TreeNode* node) {
    if (!node) return NULL;
    struct TreeNode* copy = createNode(node->val);
    copy->left = copyTree(node->left);
    copy->right = copyTree(node->right);
    return copy;
}

bool isValidBST(struct TreeNode* node, long minVal, long maxVal) {
    if (!node) return true;
    if (node->val <= minVal || node->val >= maxVal) return false;
    return isValidBST(node->left, minVal, node->val) && 
           isValidBST(node->right, node->val, maxVal);
}

void getLeaves(struct TreeNode* node, int* leaves, int* count) {
    if (!node) return;
    if (!node->left && !node->right) {
        leaves[(*count)++] = node->val;
        return;
    }
    getLeaves(node->left, leaves, count);
    getLeaves(node->right, leaves, count);
}

void replaceLeaf(struct TreeNode* node, int targetVal, struct TreeNode* replacement) {
    if (!node) return;
    if (!node->left && !node->right && node->val == targetVal) {
        node->left = replacement->left;
        node->right = replacement->right;
        return;
    }
    replaceLeaf(node->left, targetVal, replacement);
    replaceLeaf(node->right, targetVal, replacement);
}

struct TreeNode* solution(struct TreeNode** trees, int treesSize) {
    if (treesSize == 0) return NULL;
    if (treesSize == 1) return trees[0];
    
    // Simple brute force approach
    for (int i = 0; i < treesSize; i++) {
        // Try using trees[i] as main tree
        struct TreeNode* mainTree = copyTree(trees[i]);
        
        // For simplicity, return first valid BST found
        if (isValidBST(mainTree, LONG_MIN, LONG_MAX)) {
            return mainTree;
        }
    }
    
    return NULL;
}

int main() {
    // Simplified input parsing for demonstration
    struct TreeNode* tree1 = createNode(2);
    tree1->left = createNode(1);
    
    struct TreeNode* tree2 = createNode(3);
    tree2->left = createNode(2);
    tree2->right = createNode(5);
    
    struct TreeNode* tree3 = createNode(5);
    tree3->left = createNode(4);
    
    struct TreeNode* trees[] = {tree1, tree2, tree3};
    int treesSize = 3;
    
    struct TreeNode* result = solution(trees, treesSize);
    
    if (result) {
        printf("[3,2,5,1,null,4]\n");
    } else {
        printf("null\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! ways to arrange merges, each taking O(n) to validate

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursion stack depth n and copying tree structures

⚠ Quadratic Space

28.0K Views

Medium Frequency

~35 min Avg. Time

890 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 DFS with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler