Leetcode: Unique Binary Search Trees II

Given 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
confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.


OJ's Binary Tree Serialization:
The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:
   1
  / 
 2   3
    /
   4
    
     5
The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}".

难度：98。没有做出来的一道题，很难，参考了其他人的想法，发现基本上只有一个版本，在纸上按照它的步骤推了几步终于看懂了。分析如下：

第一次遇到这种让你construct a BST的问题，而且结果并不是建立一个ArrayList<ArrayList<Integer>>型的，而是建立一个ArrayList<TreeNode>型的，这我就不知道怎么搞了，看了别人的才发现原来只要把几种方案的root放在最终的结果ArrayList<TreeNode>里面就好了，每个root有自己的left & right，但是不用放在这个ArrayList里面，只要指定好就可以了。Note that current node needed to be created for each possible sub-tree setting. 

以上是本问题的难点和不熟悉的地方，本题的思路参考了http://blog.csdn.net/linhuanmars/article/details/24761437

 choose one number i from n as root, pass all the numbers less than i to recursive call to construct the current root's left sub-tree, pass all the numbers greater than i to the recursive call to construct the current root's right sub-tree.  Take n=5 for example, when we choose root node = 3, then put 1,2 to recursive call to construct root node's left sub-tree, and put 4,5 to recursive call to contract root's right subtree.

这里helper(int left, int right)函数的作用是：用left到right这几个数来构造树的当前这一层，根节点i 依次从[left, right]里取值，左子树的构造通过递归helper(left, i-1)函数, 右子树的构造通过递归helper(i+1, right)，然后返回值这样取：对于每一个（根节点，左子树，右子树）的组合模式，添加一次根节点进结果集。其实这样的结果集就是以[left, right]所有数字构成的所有BST的根的集合

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; left = null; right = null; }
 * }
 */
public class Solution {
    public ArrayList<TreeNode> generateTrees(int n) {
        if (n <= 0) return new ArrayList<TreeNode>();
        return helper(1, n);
    }
    
    public ArrayList<TreeNode> helper(int left, int right){
        ArrayList<TreeNode> rs = new ArrayList<TreeNode>();
        if(left>right) rs.add(null);
        else{
            for(int i=left; i<=right; i++){
                ArrayList<TreeNode> leftNodeSet = helper(left, i-1);
                ArrayList<TreeNode> rightNodeSet = helper(i+1, right);
            
                for(int j=0; j<leftNodeSet.size(); j++){
                    for(int k=0; k<rightNodeSet.size(); k++){
                        TreeNode curr = new TreeNode(i);
                        curr.left = leftNodeSet.get(j);
                        curr.right = rightNodeSet.get(k);
                        rs.add(curr);
                    }
                }
            }
        }
        return rs;
    }
}

public class Solution {
    public List<TreeNode> generateTrees(int n) {
        ArrayList<TreeNode> res = new ArrayList<TreeNode>();
        if (n < 0) {
            return res;
        }
        return helper(1, n);
    }
    
    public ArrayList<TreeNode> helper(int l, int r) {
        ArrayList<TreeNode> res = new ArrayList<TreeNode>();
        if (l > r) {
            res.add(null);
        }
        for (int i=l; i<=r; i++) {
            ArrayList<TreeNode> leftset = helper(l, i-1);
            ArrayList<TreeNode> rightset = helper(i+1, r);
            for (int x=0; x<leftset.size(); x++) {
                for (int y=0; y<rightset.size(); y++) {
                    TreeNode root = new TreeNode(i);
                    root.left = leftset.get(x);
                    root.right = rightset.get(y);
                    res.add(root);
                }
            }
        }
        return res;
    }
}

 注意12-14行，不是return res, 这样res是[], 而是res.add(null); 这样res是[{}]。而且这样也保证了18行一定能进循环，否则leftset size为0，rightset size不为0的case进不了循环