Unique Binary Search Trees - Practice Coding Problems

Unique Binary Search Trees - Problem

Given an integer n, calculate how many structurally unique Binary Search Trees (BSTs) can be constructed using exactly n nodes with unique values from 1 to n.

A BST is structurally unique if it has a different shape or structure, regardless of the actual values. For example, with n = 3, we can form 5 different BST structures using values 1, 2, 3.

Goal: Return the total count of unique BST structures possible.

Key Insight: This is a classic application of Catalan Numbers - a mathematical sequence that appears in many combinatorial problems involving tree structures.

Input & Output

example_1.py — Small Tree

$ Input: n = 3

› Output: 5

💡 Note: With nodes {1,2,3}, we can form 5 structurally different BSTs: Root=1 (2 ways), Root=2 (1 way), Root=3 (2 ways). Total = 2+1+2 = 5 unique structures.

example_2.py — Single Node

$ Input: n = 1

› Output: 1

💡 Note: With only one node, there's exactly one way to form a BST: a single root node. This is a base case.

example_3.py — Larger Tree

$ Input: n = 4

› Output: 14

💡 Note: With 4 nodes, we get the 4th Catalan number. Root=1: 1×5=5 ways, Root=2: 1×2=2 ways, Root=3: 2×1=2 ways, Root=4: 5×1=5 ways. Total = 5+2+2+5 = 14.

Constraints

1 ≤ n ≤ 19
Answer fits in a 32-bit signed integer
Node values are from 1 to n (consecutive integers)

Visualization

Tap to expand

Understanding the Visualization

Choose Foundation

Pick any number 1 to n as the root foundation

Divide Blocks

Smaller numbers go left, larger numbers go right

Count Combinations

Multiply left possibilities × right possibilities

Sum All Choices

Add up results for all possible foundation choices

Key Takeaway

🎯 Key Insight: This is the nth Catalan Number! The pattern C(n) = Σ C(i-1) × C(n-i) appears in many tree-counting problems.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses Dynamic Programming with O(n²) time complexity. This problem represents the famous Catalan Numbers sequence. For each number of nodes, we try each possible root and multiply the number of left subtree possibilities with right subtree possibilities, building the solution bottom-up to avoid redundant calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n)	Build solution bottom-up using memoization to avoid recomputation
Brute Force Recursion	O(4^n)	O(n)	Recursively count BSTs by trying each node as root

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP array with base cases: dp[0] = 1, dp[1] = 1
For each number of nodes from 2 to n:
For each possible root position i:
Multiply left subtree count dp[i-1] with right subtree count dp[n-i]
Sum all root choices to get dp[n]
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

dp[0] = 1, dp[1] = 1

Build Up

For each n, use previously computed values

Sum Products

dp[n] = Σ dp[i-1] × dp[n-i]

Final Answer

Return dp[n] as result

Code -

solution.c — C

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

int numTrees(int n) {
    // dp[i] represents number of unique BSTs with i nodes
    int* dp = (int*)calloc(n + 1, sizeof(int));
    
    // Base cases
    dp[0] = 1; // Empty tree
    if (n >= 1) dp[1] = 1; // Single node tree
    
    // Fill dp table for 2 to n nodes
    for (int nodes = 2; nodes <= n; nodes++) {
        for (int root = 1; root <= nodes; root++) {
            int leftNodes = root - 1;
            int rightNodes = nodes - root;
            dp[nodes] += dp[leftNodes] * dp[rightNodes];
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop runs up to n times for each iteration

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n+1 to store intermediate results

⚡ Linearithmic Space

89.3K Views

Medium Frequency

~15 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler