Unique Binary Search Trees II

Unique Binary Search Trees II - Problem

Generate All Unique Binary Search Trees

Given an integer n, your task is to generate all structurally unique Binary Search Trees (BSTs) that store exactly n nodes with unique values from 1 to n.

A Binary Search Tree is a binary tree where:
• Left subtree contains nodes with values less than the root
• Right subtree contains nodes with values greater than the root
• Both left and right subtrees are also BSTs

What makes trees structurally unique?
Trees are considered structurally different if they have different shapes or different arrangements of nodes, even if they contain the same values.

Example: For n = 3, we need to find all unique BSTs using values {1, 2, 3}. Different root choices and arrangements create structurally different trees.

Return the answer as a list of tree root nodes in any order.

Input & Output

example_1.py — Basic Case

$ Input: n = 3

› Output: 5 unique BST structures using values [1,2,3]

💡 Note: For n=3, we can create 5 structurally unique BSTs: (1) root=1, right subtree=2→3; (2) root=1, right subtree=3←2; (3) root=2, left=1, right=3; (4) root=3, left subtree=1→2; (5) root=3, left subtree=2←1

example_2.py — Minimal Case

$ Input: n = 1

› Output: 1 unique BST with single node [1]

💡 Note: With only one node, there's exactly one way to build the BST - a single node with value 1

example_3.py — Small Case

$ Input: n = 2

› Output: 2 unique BST structures using values [1,2]

💡 Note: For n=2, we get 2 unique BSTs: (1) root=1, right child=2; (2) root=2, left child=1

Constraints

1 ≤ n ≤ 8
Each BST must contain exactly n nodes
Node values must be unique integers from 1 to n
Trees must follow BST property: left < root < right

Visualization

Tap to expand

Asked in

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

The optimal approach uses recursive divide-and-conquer to generate all unique BSTs. For each possible root value, we recursively build all possible left and right subtrees, then combine them systematically. The key insight is that BST structure is determined by root choice, and we can build subtrees independently using the same logic.

Common Approaches

✓ Recursive Generation (Divide & Conquer)

⏱️ Time: O(4^n / n^0.5) Space: O(4^n / n^0.5)

For each possible root value i in range [start, end], recursively generate all possible left subtrees (values < i) and right subtrees (values > i), then combine them. This approach systematically explores all structural possibilities.

Recursive Generation (Divide & Conquer) — Algorithm Steps

Base case: if start > end, return [None] (empty subtree)
For each value i from start to end: use i as root
Recursively generate all left subtrees with values [start, i-1]
Recursively generate all right subtrees with values [i+1, end]
Combine each left subtree with each right subtree to form complete trees
Return list of all generated trees

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Root 1

Root=1, left=[], right=[2,3]

Choose Root 2

Root=2, left=[1], right=[3]

Choose Root 3

Root=3, left=[1,2], right=[]

Combine Results

Generate all combinations of left and right subtrees

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 = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode** generate(int start, int end, int* returnSize) {
    if (start > end) {
        struct TreeNode** result = (struct TreeNode**)malloc(sizeof(struct TreeNode*));
        result[0] = NULL;
        *returnSize = 1;
        return result;
    }
    
    struct TreeNode** result = (struct TreeNode**)malloc(10000 * sizeof(struct TreeNode*));
    int totalCount = 0;
    
    for (int i = start; i <= end; i++) {
        int leftSize, rightSize;
        struct TreeNode** left_trees = generate(start, i - 1, &leftSize);
        struct TreeNode** right_trees = generate(i + 1, end, &rightSize);
        
        for (int l = 0; l < leftSize; l++) {
            for (int r = 0; r < rightSize; r++) {
                struct TreeNode* root = createNode(i);
                root->left = left_trees[l];
                root->right = right_trees[r];
                result[totalCount++] = root;
            }
        }
        free(left_trees);
        free(right_trees);
    }
    
    *returnSize = totalCount;
    return result;
}

struct TreeNode** generateTrees(int n, int* returnSize) {
    if (n == 0) {
        *returnSize = 0;
        return NULL;
    }
    return generate(1, n, returnSize);
}

int main() {
    int n;
    scanf("%d", &n);
    int size;
    struct TreeNode** trees = generateTrees(n, &size);
    printf("%d\n", size);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n / n^0.5)

Catalan number complexity - exponential growth as we generate all possible BST structures

✓ Linear Growth

Space Complexity

O(4^n / n^0.5)

Space to store all generated trees, which grows exponentially with n

⚡ Linearithmic Space

67.2K Views

Medium Frequency

~25 min Avg. Time

1.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

Recursive Generation (Divide & Conquer) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler