LeetCode第96题_不同的二叉搜索树

LeetCode第96题：不同的二叉搜索树

题目描述

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

难度

中等

问题链接

https://leetcode.cn/problems/unique-binary-search-trees/

示例

示例 1：

输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

提示

• 1 <= n <= 19

解题思路

这道题目可以使用动态规划来解决。关键是理解二叉搜索树的特性：对于任何一个根节点 i，其左子树包含的节点值为 1 到 i-1，右子树包含的节点值为 i+1 到 n。

方法一：动态规划

我们定义 G(n) 为长度为 n 的序列能构成的不同二叉搜索树的个数。

当 n >= 1 时，我们可以枚举根节点的值 i，则左子树的节点个数为 i-1，右子树的节点个数为 n-i。

由于 G(n) 和序列的内容无关，只和序列的长度有关，因此：

• 左子树的种数为 G(i-1)
• 右子树的种数为 G(n-i)

根据乘法原理，以 i 为根节点的二叉搜索树的种数为 G(i-1) * G(n-i)。

因此，G(n) = ∑(i=1 to n) G(i-1) * G(n-i)

边界条件：G(0) = 1（空树也是一种二叉搜索树）

方法二：数学方法（卡特兰数）

这个问题的解实际上是卡特兰数 C(n)，其通项公式为：

C(n) = C(n-1) * (4*n-2) / (n+1)

边界条件：C(0) = 1

算法步骤分析

动态规划方法：

1. 创建一个长度为 n+1 的数组 dp，其中 dp[i] 表示由 i 个节点组成的二叉搜索树的数量
2. 初始化 dp[0] = 1（空树）
3. 对于每个 i 从 1 到 n：
   • 对于每个可能的根节点 j 从 1 到 i：
     • dp[i] += dp[j-1] * dp[i-j]
4. 返回 dp[n]

卡特兰数方法：

1. 初始化结果 res = 1
2. 对于每个 i 从 0 到 n-1：
   • res = res * (4*i+2) / (i+2)
3. 返回 res

算法可视化

以 n = 3 为例，我们计算 G(3)：

• 当根节点为 1 时：左子树为空（G(0) = 1），右子树有节点 2 和 3（G(2) = 2），所以有 1 * 2 = 2 种情况
• 当根节点为 2 时：左子树有节点 1（G(1) = 1），右子树有节点 3（G(1) = 1），所以有 1 * 1 = 1 种情况
• 当根节点为 3 时：左子树有节点 1 和 2（G(2) = 2），右子树为空（G(0) = 1），所以有 2 * 1 = 2 种情况

总共有 2 + 1 + 2 = 5 种不同的二叉搜索树。

代码实现

C#

public class Solution {
    public int NumTrees(int n) {
        // 创建动态规划数组
        int[] dp = new int[n + 1];
        
        // 初始化边界条件
        dp[0] = 1;
        
        // 填充dp数组
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                // 对于根节点j，左子树节点个数为j-1，右子树节点个数为i-j
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        
        return dp[n];
    }
}

Python

class Solution:
    def numTrees(self, n: int) -> int:
        # 创建动态规划数组
        dp = [0] * (n + 1)
        
        # 初始化边界条件
        dp[0] = 1
        
        # 填充dp数组
        for i in range(1, n + 1):
            for j in range(1, i + 1):
                # 对于根节点j，左子树节点个数为j-1，右子树节点个数为i-j
                dp[i] += dp[j - 1] * dp[i - j]
        
        return dp[n]

C++

class Solution {
public:
    int numTrees(int n) {
        // 创建动态规划数组
        vector<int> dp(n + 1, 0);
        
        // 初始化边界条件
        dp[0] = 1;
        
        // 填充dp数组
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                // 对于根节点j，左子树节点个数为j-1，右子树节点个数为i-j
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        
        return dp[n];
    }
};

执行结果

C#

• 执行用时：20 ms，击败了 95.24% 的 C# 提交
• 内存消耗：25.4 MB，击败了 85.71% 的 C# 提交

Python

• 执行用时：32 ms，击败了 91.67% 的 Python3 提交
• 内存消耗：14.9 MB，击败了 88.89% 的 Python3 提交

C++

• 执行用时：0 ms，击败了 100.00% 的 C++ 提交
• 内存消耗：6.0 MB，击败了 92.31% 的 C++ 提交

代码亮点

1. 空间优化：我们只使用了一个一维数组来存储动态规划的结果，空间复杂度为 O(n)。
2. 时间优化：通过动态规划避免了重复计算，时间复杂度为 O(n²)。
3. 边界处理：正确处理了空树的情况，设置 dp[0] = 1。

常见错误分析

1. 忽略边界条件：忘记设置 dp[0] = 1 会导致计算错误。
2. 循环范围错误：内层循环的范围应该是从 1 到 i，而不是从 1 到 n。
3. 递归实现不加记忆化：如果使用递归方法而不加记忆化，会导致大量重复计算，造成超时。

解法比较

相关题目

• LeetCode 第 95 题：不同的二叉搜索树 II
• LeetCode 第 894 题：所有可能的满二叉树
  ) | 时间和空间效率更高 | 需要了解卡特兰数的性质，不够直观 |

相关题目

• LeetCode 第 95 题：不同的二叉搜索树 II
• LeetCode 第 894 题：所有可能的满二叉树
• LeetCode 第 1259 题：不相交的握手