Leetcode 96 95 不同的二叉搜索树(动态规划、搜索树) 不同的二叉搜索树II (递归、搜索树)

1.不同的二叉搜索树

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

示例:

输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

思路：动态规划及二叉搜索树性质问题

1. 二叉搜索树性质：节点i左边的节点值 $x$小于或等于节点 $i$的值，即 $x<=i$, 节点 $i$右边的节点值 $y$大于节点i的值，即 $i<y$;
2. 动态规划：设有2个结点, 则2个结点时二叉搜索树情况为: dp[2]=dp[0]*dp[1]+dp[1]*dp[0]; 这里dp[0]*dp[1]指在根节点左边有0个节点，在右边有1个节点; dp[1]*dp[0]指的是右边有一个节点，左边有0个节点。不同形态的二叉查找树的个数，就是根节点的 左子树的个数乘以右子树的个数，就是左边的所有情况乘以右边的所有情况，知道这个规律就好做啦。
3. 动态规划转移方程：dp[i]=dp[i]+dp[j]*dp[i-j-1] (其中i代表节点个数，j代表在i节点左边共有j个节点)

class Solution {
public:
    int numTrees(int n) {
        if(n==0) return 0;
        if(n==1) return 1;
        vector<int> result(n+1,0);
        result[0]=1;
        result[1]=1;
        for(int i=2;i<n+1;i++){  //表示根节点
            for(int j=0;j<n;j++){  //表示根节点左边的节点个数
                result[i] += result[j]*result[i-j-1];
            }
        }
        return result[n];
    }
};

1.不同的二叉搜索树II

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

示例:

输入: 3
输出:
[
[1,null,3,2],
[3,2,null,1],
[3,1,null,null,2],
[2,1,3],
[1,null,2,null,3]
]
解释:
以上的输出对应以下 5 种不同结构的二叉搜索树：

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

思路：这属于建树部分，一般是用递归。首先new一个空间，用于存放所有可能的树，至于为什么要用指针，参考网上大佬的。注意这里的边界条件是start>end的时候停止，并返回NULL。然后至于用俩个循环的原因是：假设n=4, 且i=3, 其实对于左子树而言，有俩种情况，对于右子树而言，只有一种情况，所以需要遍历得到所有情况：

              3                3 
            /  \             /    \
          2     4           1      4
        /                    \
      1                        2

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        if(n==0) return {};
        return *getSubTree(1,n);
    }
    vector<TreeNode*>* getSubTree(int start,int end){
       vector<TreeNode*> *SubTree=new vector<TreeNode*>();
       if(start>end){
           SubTree->push_back(NULL);
       }
       else{
           for(int i=start;i<=end;i++){
               vector<TreeNode*> *leftSubTree=getSubTree(start,i-1);
               vector<TreeNode*> *rightSubTree=getSubTree(i+1,end);
               for(int j=0;j<(*leftSubTree).size();j++){
                    for(int k=0;k<(*rightSubTree).size();k++){
                    TreeNode* Node=new TreeNode(i);
                    Node->left=(*leftSubTree)[j];
                    Node->right=(*rightSubTree)[k];
                    SubTree->push_back(Node);
               }
           }
         }
       }
        return SubTree;
    }
};```