leedcode做题总结, 题目Unique Binary Search TreesI/II95/96

这两道题使用的是递归，一次以每一个节点作为父节点然后对两边进行递归即可，第二题是要返回所有序列，用递归从下向上传回来即可。

public class Solution {

    private int generate(int i, int j){
        if(i>=j)
            return 1;
        int sum=0;
        for(int k=i;k<=j;k++){
            sum+=generate(i,k-1)*generate(k+1,j);
        }
        return sum;
    }

    public int numTrees(int n) {
        if(n ==0 || n ==1 || n==2){
            return n;
        }
        int sum=0;

        sum=generate(0,n-1);

        return sum;
    }
}

public class Solution {
    private ArrayList<TreeNode> generate(int i, int j){
        if(i==j){
            TreeNode t = new TreeNode(i+1);
            ArrayList<TreeNode> l = new ArrayList<TreeNode>();
            l.add(t);
            return l;

        }else if(i<j){

            ArrayList<TreeNode> l1;
            ArrayList<TreeNode> l2;
            ArrayList<TreeNode> l = new ArrayList<TreeNode>();
            for(int k=i;k<=j;k++){
                l1=generate(i,k-1);
                l2=generate(k+1,j);
                if(l1!=null && l2 != null){
                    for(int m=0;m<l1.size();m++){

                        for(int n=0;n<l2.size();n++){
                            TreeNode t = new TreeNode(k+1);
                            t.left=l1.get(m);
                            t.right=l2.get(n);
                            l.add(t);
                        }
                    }
                }else if(l1==null && l2 != null){
                    for(int n=0;n<l2.size();n++){
                        TreeNode t = new TreeNode(k+1);
                        t.right=l2.get(n);
                        l.add(t);

                    }

                }else if(l1!=null && l2 == null){
                    for(int m=0;m<l1.size();m++){
                        TreeNode t = new TreeNode(k+1);
                        t.left=l1.get(m);
                        l.add(t);

                    }

                }
            }
            return l;
        }

        return null;
    }
    public List<TreeNode> generateTrees(int n) {
        ArrayList<TreeNode> l = new ArrayList<TreeNode>();
        if(n ==0 ){
            l.add(null);
            return l;
        }

        l=generate(0,n-1);

        return l;
    }
}

Update 2015/09/01：这个题思路都算正确，九章里的答案更简洁

public class Solution {
    /**
     * @paramn n: An integer
     * @return: An integer
     */
    public int numTrees(int n) {
        // write your code here
        int[] count = new int[n+2];
        count[0] = 1;
        count[1] = 1;
        
        for(int i=2;  i<= n; i++){
            for(int j=0; j<i; j++){
                count[i] += count[j] * count[i - j - 1];
            }
        }
        return count[n];
    }
}

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    private ArrayList<TreeNode> generate(int start, int end){
        ArrayList<TreeNode> rst = new ArrayList<TreeNode>();   
    
        if(start > end){
            rst.add(null);
            return rst;
        }
        for(int i=start; i<=end; i++){
            ArrayList<TreeNode> left = generate(start, i-1);
            ArrayList<TreeNode> right = generate(i+1, end);
            for(TreeNode l: left){
                for(TreeNode r: right){
                    TreeNode root = new TreeNode(i);  
                    root.left = l;
                    root.right = r;
                    rst.add(root);
                }
            }
        }
            
        return rst;
    }
    /**
     * @paramn n: An integer
     * @return: A list of root
     */
    public List<TreeNode> generateTrees(int n) {
        // write your code here
        return generate(1, n);
    }
}