LeetCode不同的二叉搜索树（动态规划）

Posted 2023-04-09 小锦鲤yaw

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

 

示例 1：

输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

提示：

• 1 <= n <= 19 

思路分析：（动态规划）

• 题目要求我们计算出由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？我们假设n个结点的个数为SUM(n)
• 令Count(i)为以i为根的二叉搜索树的个数
• SUM(n) = Count(1) + Count(2) + Count(3) + ...... + Count(n);
• 当 i 为根节点时，其左子树节点个数为 i-1 个，右子树节点为 n-i;

图解：

     

代码展示：

public int numTrees(int n) 
        int [] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for(int i = 2; i <= n; i++)
            for(int j = 1; j <= i; j++)
                dp[i] += dp[j-1] * dp[i-j];
            
        
        return dp[n];
    

2.不同的二叉搜索树 II

给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。

 

示例 1：

输入：n = 3
输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

• 1 <= n <= 8

 思路分析：

• 在上一题的基础上，这道题不仅要求算出二叉搜索树的个数，还要求我们一一打印出来

代码展示：

/**
 * Definition for a binary tree node.
 * public class TreeNode 
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() 
 *     TreeNode(int val)  this.val = val; 
 *     TreeNode(int val, TreeNode left, TreeNode right) 
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     
 * 
 */
class Solution 
    public List<TreeNode> generateTrees(int n) 
        List<TreeNode> [] dp = new ArrayList[n+1];
        dp[0] = new ArrayList<>();
        dp[0].add(null);
        for(int i = 1; i <= n; i++)
            dp[i] = new ArrayList<>();
            for(int root = 1; root <= i; root++)
            int left = root - 1;
            int right = i - root;
            //遍历所有的可能
            for(TreeNode leftTree : dp[left])
                for(TreeNode rightTree : dp[right])
                    TreeNode newRoot = new TreeNode(root);
                    newRoot.left = leftTree;
                    newRoot.right = clone(root,rightTree);
                    dp[i].add(newRoot);
                
            

        
        
        return dp[n];
    
    public TreeNode clone(int val, TreeNode root)
        if(root == null)
            return null;
        
        TreeNode newRoot = new TreeNode(val + root.val);
        newRoot.left = clone(val,root.left);
        newRoot.right = clone(val,root.right);
        return newRoot;

    

 

 

 

 

Leetcode练习(Python)：动态规划类：第95题：不同的二叉搜索树 II：给定一个整数 n，生成所有由 1 ... n 为节点所组成的二叉搜索树。

题目：

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

思路：

遍历每一个节点，并且得到每个节点的左右子树，然后获得每个子树的样子就可以得出来了。

自己想了半天没法实现，参考了一下网上大神的程序，写的很好，很好理解。

程序：

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

class Solution:
    def generateTrees(self, n: int) -> List[TreeNode]:
        if n <= 0:
            return []
        def auxiliary(begin, end):
            auxiliary_result = []
            if begin > end:
                return [None]
            for index in range(begin, end + 1):
                left_part = auxiliary(begin, index - 1)
                right_part = auxiliary(index + 1, end)
                for left_node in left_part:
                    for right_node in right_part:
                        tree_node = TreeNode(index)
                        tree_node.left = left_node
                        auxiliary_result.append(tree_node)
                        tree_node.right = right_node
            return auxiliary_result
        result = auxiliary(1, n)
        return result