[LeetCode] 96. 不同的二叉搜索树 ➕ 95. 不同的二叉搜索树 II

1 题目描述

• 96. 不同的二叉搜索树
  给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？
  

• 95. 不同的二叉搜索树 II
      给定一个整数 n，生成所有由 1 … n 为节点所组成的二叉搜索树。
      

2 解题思路

• 96. 不同的二叉搜索树 – 动态规划解法
  本问题可以用动态规划求解。

给定一个有序序列 1 … n，为了根据序列构建一棵二叉搜索树。我们可以遍历每个数字 i，将该数字作为树根，1 … (i-1) 序列将成为左子树，(i+1) … n 序列将成为右子树。于是，我们可以递归地从子序列构建子树。
在上述方法中，由于根各自不同，每棵二叉树都保证是独特的。

可见，问题可以分解成规模较小的子问题。因此，我们可以存储并复用子问题的解，而不是递归的（也重复的）解决这些子问题，这就是动态规划法。
问题是计算不同二叉搜索树的个数。为此，我们可以定义两个函数：G(n): 长度为n的序列的不同二叉搜索树个数。F(i,n): 以i为根的不同二叉搜索树个数(1≤i≤n)。
可见，G(n) 是我们解决问题需要的函数。

---

• 95. 不同的二叉搜索树 II 递归解法
      
      作者：LeetCode
      链接：https://leetcode-cn.com/problems/unique-binary-search-trees/solution/bu-tong-de-er-cha-sou-suo-shu-by-leetcode/
      来源：力扣（LeetCode）
      著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3 解决代码

• 96. 不同的二叉搜索树 – 动态规划解法 Java代码

class Solution {
    public int numTrees(int n) {
        int[] G = new int[n + 1];
        G[0] = 1;
        G[1] = 1;
        
        for(int i = 2; i <= n;i++){
            for(int j = 1; j <= i; j++){
                G[i] += G[j - 1] * G[i - j];
            }
        }
        return G[n];

    }
}

• 96. 不同的二叉搜索树 – 动态规划解法 python解法

class Solution:
    def numTrees(self, n: int) -> int:
        G = [0] * (n + 1)
        G[0], G[1] = 1, 1
        
        for i in range(2, n + 1):
            for j in range(1, i + 1):
                G[i] += G[j - 1] * G[i - j]
        return G[n]

---

• 95. 不同的二叉搜索树 II 递归解法 java 代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<TreeNode> generateTrees(int n) {
        if(n == 0){
            return new LinkedList<TreeNode>();
        }
        return generate_Trees(1, n);
    }
    
    public LinkedList<TreeNode> generate_Trees(int start, int end){
        LinkedList<TreeNode>  all_Trees =  new LinkedList<TreeNode>();
        if(start > end){
            all_Trees.add(null);
            return all_Trees;
        }
        for(int i = start; i <= end; i++){
            LinkedList<TreeNode> left_Trees = generate_Trees(start, i - 1);
            LinkedList<TreeNode> right_Trees = generate_Trees(i + 1, end);
            
            for (TreeNode left: left_Trees){
                for(TreeNode right: right_Trees){
                    TreeNode current_Tree = new TreeNode(i);
                    current_Tree.left = left;
                    current_Tree.right = right;
                    all_Trees.add(current_Tree);
                }
            }
        }
        return all_Trees;
    }
}

• 95. 不同的二叉搜索树 II 递归解法 python 代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def generateTrees(self, n):
        """
        :type n: int
        :rtype: List[TreeNode]
        """
        def generate_Trees(start, end):
            if(start > end):
                return [None,]
            all_trees = []
            for i in range(start, end + 1): 
                left_trees = generate_Trees(start, i -1)
                right_trees = generate_Trees(i +1, end)
                for left in left_trees:
                    for right in right_trees:
                        current_tree = TreeNode(i)
                        current_tree.left = left
                        current_tree.right = right
                        all_trees.append(current_tree)
            return all_trees
        return generate_Trees(1, n) if n else []