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

方法一

使用递归，DFS遍历。

    public List<TreeNode> getTrees(int start, int end) {
	
	    List<TreeNode> list = new ArrayList<TreeNode>();
        if (start > end) {
            list.add(null);
            return list;
        }
        
        for (int i = start; i <= end; i++) {
            List<TreeNode> left = getTrees(start, i - 1);
            List<TreeNode> right = getTrees(i + 1, end);
            for (int j = 0; j < left.size(); j++) {
                for (int k = 0; k < right.size(); k++) {
                    TreeNode root = new TreeNode(i);
                    root.left = left.get(j);
                    root.right = right.get(k);
                    list.add(root);
                }
            }
        }
        return list;
    }

	public List<TreeNode> generateTrees(int n) {
	    return getTrees(1, n);
	}

方法二

将递归转换为迭代，思想和方法一类似。

//    public TreeNode clone(TreeNode root, int j) {
//		if (root == null) {
//			return null;
//		}
//		TreeNode node = new TreeNode(root.val + j);
//		node.left = clone(root.left, j);
//		node.right = clone(root.right, j);
//		return node;
//	}
//
//	public List<TreeNode> generateTrees(int n) {
//	    List<List<TreeNode>> list = new ArrayList<List<TreeNode>>();
//	    List<TreeNode> zero = new ArrayList<TreeNode>();
//	    TreeNode zeroNode = null;
//	    zero.add(zeroNode);
//	    List<TreeNode> one = new ArrayList<TreeNode>();
//	    TreeNode oneNode = new TreeNode(1);
//	    one.add(oneNode);
//	    List<TreeNode> two = new ArrayList<TreeNode>();
//	    TreeNode twoNodeFirst = new TreeNode(1);
//	    twoNodeFirst.right = new TreeNode(2);
//	    TreeNode twoNodeSecond = new TreeNode(2);
//	    twoNodeSecond.left = new TreeNode(1);
//	    two.add(twoNodeFirst);
//	    two.add(twoNodeSecond);
//	    list.add(zero);
//	    list.add(one);
//	    list.add(two);
//	    if (n <= 2) {
//	        return list.get(n);
//	    }
//	    for (int i = 3; i <= n; i++) {
//	        List<TreeNode> cur = new ArrayList<TreeNode>();
//	        int len = i;
//	        for (int j = 1; j <= len; j++) {
//	            List<TreeNode> left = list.get(j - 1);
//	            int leftSize =  left.size();
//	            List<TreeNode>  right = list.get(len - j);
//	            int rightSize =  right.size();
//	            for (int p = 0; p < leftSize; p++) {
//	
//	                for (int q = 0; q < rightSize; q++) {
//	                    TreeNode root = new TreeNode(j);
//	                    
//	                    TreeNode leftNode = left.get(p);
//	                    TreeNode rightNode = right.get(q);
//	                    if (rightNode == null) {
//	                        root.right = rightNode;
//	                    } else {
//	                        TreeNode newRightNode = clone(rightNode, j);
//	                        root.right = newRightNode;
//	                    }
//	                    root.left = leftNode;
//	                    cur.add(root);
//	                }
//	            }
//	        }
//	        list.add(cur);
//	    }
//	    return list.get(n);
//	}