Unique Binary Search Trees

Unique Binary Search Trees - Problem

Given an integer n, return the number of structurally unique BST's (binary search trees) which has exactly n nodes of unique values from 1 to n.

A Binary Search Tree (BST) is a tree where for each node:

All values in the left subtree are less than the node's value
All values in the right subtree are greater than the node's value

Structurally unique means trees with different shapes, even if they contain the same values in different arrangements.

Input & Output

Example 1 — Small Case

$ Input: n = 3

› Output: 5

💡 Note: With 3 nodes (1,2,3), we can form 5 structurally unique BSTs: root=1 gives 2 trees, root=2 gives 1 tree, root=3 gives 2 trees. Total: 2+1+2=5

Example 2 — Base Case

$ Input: n = 1

› Output: 1

💡 Note: With only 1 node, there's exactly 1 way to form a BST - just a single node tree

Example 3 — Two Nodes

$ Input: n = 2

› Output: 2

💡 Note: With 2 nodes (1,2), we can form 2 BSTs: root=1 with right child 2, or root=2 with left child 1

Constraints

1 ≤ n ≤ 19

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is recognizing that BST counts follow Catalan numbers. For each root choice, we multiply the counts of possible left and right subtrees. Best approach uses dynamic programming or direct Catalan formula. Time: O(n), Space: O(1) with math approach.

Common Approaches

✓ Catalan Numbers Formula

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

The number of unique BSTs with n nodes is the nth Catalan number. We can compute this using the formula C(n) = (2n)! / ((n+1)! × n!) or the more efficient recursive formula C(n) = Σ(C(i) × C(n-1-i)) for i from 0 to n-1.

Dynamic Programming

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

Use dynamic programming to build the solution from bottom up. dp[i] represents the number of unique BSTs with i nodes. For each i, try each possible root and sum up dp[left] × dp[right] combinations.

Memoized Recursion

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

Same recursive approach but store results in a cache to avoid recalculating the same subproblems. When we need the count for n nodes, check the cache first before computing recursively.

Recursive Brute Force

⏱️ Time: O(4ⁿ) Space: O(n)

For each possible root from 1 to n, recursively calculate the number of unique BSTs for left and right subtrees, then multiply them together. The total is the sum over all possible roots.

Catalan Numbers Formula — Algorithm Steps

Recognize this is the nth Catalan number
Use binomial coefficient formula: C(n) = C(2n,n) / (n+1)
Or compute iteratively: C(n) = C(n-1) × 2(2n-1) / (n+1)
Return the computed Catalan number

Visualization

Tap to expand

Step-by-Step Walkthrough

Pattern Recognition

BST counts = Catalan numbers

Formula Application

C(n) = C(n-1) × 2(2n-1) / (n+1)

Direct Computation

Calculate result in O(n) time

Code -

solution.c — C

#include <stdio.h>

int solution(int n) {
    if (n <= 1) {
        return 1;
    }
    
    // Compute nth Catalan number using iterative formula
    // C(n) = C(n-1) * 2 * (2n-1) / (n+1)
    long long catalan = 1;
    for (int i = 1; i <= n; i++) {
        catalan = catalan * 2 * (2 * i - 1) / (i + 1);
    }
    
    return catalan;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int result = solution(n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop to compute the Catalan number using iterative formula

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables, no extra data structures needed

⚡ Linearithmic Space

230.6K Views

Medium Frequency

~15 min Avg. Time

8.5K 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

Catalan Numbers Formula — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler