LeetCode96: 不同的二叉搜索树（多解）

题目LeetCode96

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

示例

输入： n = 3
**输出：**5

Python解法

解法一（动态规划）

python 复制代码

class Solution:
    def numTrees(self, n: int) -> int:

        dp = [0] * (n + 1)
        dp[0] = 1
        dp[1] = 1
        
        for i in range(2, n + 1):
            for j in range(1, i + 1):
                dp[i] += dp[j - 1] * dp[i - j]

        return dp[n]

解释

1，首先对要计算的数组进行初始化

python 复制代码

dp = [0] * (n + 1)
dp[0] = 1
dp[1] = 1

2，从 2 个节点算到 n 个节点

python 复制代码

for i in range(2, n + 1):

3，j = 我们选谁当根节点

python 复制代码

for j in range(1, i + 1):

核心公式：dp[i] = 所有以 j 为根的情况之和

左边：j-1 个节点 → dp[j-1]

右边：i-j 个节点 → dp[i-j]

组合：左边 × 右边

python 复制代码

dp[i] += dp[j-1] * dp[i-j]

举个例子（n = 3）

dp[0] = 1

dp[1] = 1

i=2：

j=1：左 0 右 1 → 1*1=1

j=2：左 1 右 0 → 1*1=1``dp[2] = 1+1 = 2

i=3：

j=1：左 0 右 2 → 1*2=2

j=2：左 1 右 1 → 1*1=1

j=3：左 2 右 0 → 2*1=2``dp[3] = 2+1+2 = 5

所以 n=3 答案是 5，完全正确。

解法二（数学）

python 复制代码

class Solution:
    def numTrees(self, n: int) -> int:
        C = 1          # C0 = 1，第0个卡特兰数
        for i in range(0, n):
            # 递推计算下一个卡特兰数
            C = C * 2 * (2*i + 1) // (i + 2)
        return C

n 个节点的二叉搜索树数量 = 第 n 个卡特兰数

Java解法

解法一（动态规划）

java 复制代码

class Solution{
    public int numTrees(int n){
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;

        for(int i = 2; i < n + 1; i++){
            for(int j = 1; j < i + 1; j++){
                dp[i] = dp[i] + dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }
}

解法二（数学）

java 复制代码

class Solution{
    public int numTrees(int n){
        long C = 1;//较长的数据类型
        for(int i = 0; i < n; i++){
            C = C * 2 * (2*i + 1) / (i + 2);
        }
        return (int)C; //强制转换
    }
}

C++解法

解法一（动态规划）

cpp 复制代码

class Solution {
public:
    int numTrees(int n) {
        // 1. 创建 dp 数组，dp[i] 表示 i 个节点能构成的 BST 数量
        int dp[n + 1];
        // 初始化数组为 0 (C++ 局部变量不会自动清0)
        memset(dp, 0, sizeof(dp));
        
        // 2. 基础条件
        dp[0] = 1; // 0个节点，空树，1种
        dp[1] = 1; // 1个节点，1种

        // 3. 外层循环：计算 2 个节点到 n 个节点的情况
        for (int i = 2; i <= n; i++) {
            // 内层循环：以 j 作为根节点
            for (int j = 1; j <= i; j++) {
                // 核心公式：左子树 * 右子树
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        
        // 4. 返回 n 个节点的结果
        return dp[n];
    }
};

解法二（数学）

cpp 复制代码

class Solution {
public:
    int numTrees(int n) {
        // 用 long long 防止中间计算溢出
        long long C = 1;
        for (int i = 0; i < n; ++i) {
            // 递推公式：C = C * 2 * (2i + 1) / (i + 2)
            C = C * 2 * (2 * i + 1) / (i + 2);
        }
        return (int)C;
    }
};