Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1...n.

For example,
Given n = 3, your program should return all 5 unique BST's shown below.

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

他人思路：

參考https://blog.csdn.net/willduan1/article/details/51615393

首先使用動態規劃計算節點從1 到 n 可以構造的 BST 樹的個數，接下來使用遞迴就可以構造一棵 BST 樹了，基本思路是 以 i 為根節點，然後 [1, i] 區間構造左子樹，[i+1,n] 區間構造右子樹，如此不斷遞迴就構造成了一棵完整二叉樹。

程式碼（Java）：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode[] recursion (int s, int e, int[] dp) {  
        TreeNode[] roots = null;  
        int curlen = 0;  
        if (s > e) {  
            roots = new TreeNode[1];  
            roots[0] = null;  
            return roots;  
        }  
        roots = new TreeNode[dp[e - s + 1]];  
        for (int i = s; i <= e; i++) {  
            TreeNode[] lefts = recursion(s, i - 1, dp);  //遞迴構造左子樹  
            TreeNode[] rights = recursion(i + 1, e, dp);  //遞迴構造右子樹  
            for (TreeNode left : lefts) {  
                for (TreeNode right : rights) {  
                    TreeNode root = new TreeNode(i);  
                    root.left = left;  
                    root.right = right;  
                    roots[curlen++] = root;  
                }  
            }  
        }  
        return roots;  
    }  
      
    public List<TreeNode> generateTrees(int n) {  
        if (n == 0) {  
            return new ArrayList<TreeNode>();  
        } else {  
            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];  
                }     
            }     
            TreeNode[] resarr =  recursion(1, n, dp);  
            List<TreeNode> res = new ArrayList<>();  
            for (TreeNode node : resarr) {  
                res.add(node);  
            }  
            return res;  
        }  
    }      public TreeNode[] recursion (int s, int e, int[] dp) {  
        TreeNode[] roots = null;  
        int curlen = 0;  
        if (s > e) {  
            roots = new TreeNode[1];  
            roots[0] = null;  
            return roots;  
        }  
        roots = new TreeNode[dp[e - s + 1]];  
        for (int i = s; i <= e; i++) {  
            TreeNode[] lefts = recursion(s, i - 1, dp);  //遞迴構造左子樹  
            TreeNode[] rights = recursion(i + 1, e, dp);  //遞迴構造右子樹  
            for (TreeNode left : lefts) {  
                for (TreeNode right : rights) {  
                    TreeNode root = new TreeNode(i);  
                    root.left = left;  
                    root.right = right;  
                    roots[curlen++] = root;  
                }  
            }  
        }  
        return roots;  
    }  
      
    public List<TreeNode> generateTrees(int n) {  
        if (n == 0) {  
            return new ArrayList<TreeNode>();  
        } else {  
            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];  
                }     
            }     
            TreeNode[] resarr =  recursion(1, n, dp);  
            List<TreeNode> res = new ArrayList<>();  
            for (TreeNode node : resarr) {  
                res.add(node);  
            }  
            return res;  
        }  
    }      public TreeNode[] recursion (int s, int e, int[] dp) {  
        TreeNode[] roots = null;  
        int curlen = 0;  
        if (s > e) {  
            roots = new TreeNode[1];  
            roots[0] = null;  
            return roots;  
        }  
        roots = new TreeNode[dp[e - s + 1]];  
        for (int i = s; i <= e; i++) {  
            TreeNode[] lefts = recursion(s, i - 1, dp);  //遞迴構造左子樹  
            TreeNode[] rights = recursion(i + 1, e, dp);  //遞迴構造右子樹  
            for (TreeNode left : lefts) {  
                for (TreeNode right : rights) {  
                    TreeNode root = new TreeNode(i);  
                    root.left = left;  
                    root.right = right;  
                    roots[curlen++] = root;  
                }  
            }  
        }  
        return roots;  
    }  
      
    public List<TreeNode> generateTrees(int n) {  
        if (n == 0) {  
            return new ArrayList<TreeNode>();  
        } else {  
            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];  
                }     
            }     
            TreeNode[] resarr =  recursion(1, n, dp);  
            List<TreeNode> res = new ArrayList<>();  
            for (TreeNode node : resarr) {  
                res.add(node);  
            }  
            return res;  
        }  
    }  
}