本题其实不算太难，不过我被标签 Dynamic Programming迷惑了，反倒没有往Recursive的方向努力想。
    Dynamic Programming也是可以解出来的，近似于Unique Binary Search Trees，但是有缺点：

    1. 当构建新的Tree的时候，可以利用之前的数，但是需要给一个offset，并且克隆，其实这样就用了更多的空间
    2. 相比Recursive，Dynamic Programming是手动memorize一些东西，节省时间，浪费空间(如果忽略recursive本身用的空间)。但是本题时间上，空间上表现都会更差

    本题不分析时间空间复杂度
    代码也比较好懂，解释半天反倒变复杂了，非常常规的Recurseive题目:

    1. /**
    2.  * Definition for a binary tree node.
    3.  * public class TreeNode {
    4.  *     int val;
    5.  *     TreeNode left;
    6.  *     TreeNode right;
    7.  *     TreeNode() {}
    8.  *     TreeNode(int val) { this.val = val; }
    9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
    10.  *         this.val = val;
    11.  *         this.left = left;
    12.  *         this.right = right;
    13.  *     }
    14.  * }
    15.  */
    17. class Solution {
    18.   public List<TreeNode> generateTrees(int n) {
    19.     if (n == 0) {
    20.       return new ArrayList<>();
    21.     }
    22.     return helper(1, n);
    23.   }
    25.   private List<TreeNode> helper(int start, int end) {
    26.     List<TreeNode> subResult = new ArrayList<>();
    27.     if (start > end) {
    28.       subResult.add(null);
    29.     }
    30.     else {
    31.       for (int index = start; index <= end; ++index) {
    32.         List<TreeNode> leftLst = helper(start, index - 1);
    33.         List<TreeNode> rightLst = helper(index + 1, end);
    34.         for (TreeNode l : leftLst) {
    35.           for (TreeNode r : rightLst) {
    36.             TreeNode root = new TreeNode(index);
    37.             root.left = l;
    38.             root.right = r;
    39.             subResult.add(root);
    40.           }
    41.         }
    42.       }
    43.     }
    44.     return subResult;
    45.   }
    46. }