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

是第96题的延伸，要求出所有可能性。

 

 

刚开始写了一个回溯法，但是由于没有办法在TreeNode中重写equals，导致需要重写的东西很多（主要这样做的话，一个一个添加TreeNode。会出现重复的情况），也就导致了时间很长。一百多ms。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    List list = new ArrayList<TreeNode>();
    public List<TreeNode> generateTrees(int n) {
        
        if( n == 0)
            return list;
        int[] pos = new int[n];
        for( int i = 0;i<n;i++){
            pos[i] = 1;
            TreeNode root = new TreeNode(i+1);
            getResult(root,pos);
            pos[i] = 0;
        }
        return list;
    }

    public void getResult(TreeNode root,int[] pos){

        int flag = 0;
        for( int i = 0;i<pos.length;i++){
            if( pos[i] == 0){
                addNode(root,i);
                pos[i] = 1;
                getResult(root,pos);
                delNote(root,i);
                pos[i] = 0;
                flag = 1;
            }
        }
        if( flag == 0){
            TreeNode ans = getAns(root);
            if( !isExist(ans) )
                list.add(ans);
        }
            

    }
    public boolean isExist(TreeNode ans){
        int size = list.size();
        for( int i = 0;i<size;i++){
            if( isSame((TreeNode)list.get(i),ans) )
                return true;
        }
        return false;
              
    }
    public boolean isSame(TreeNode node1,TreeNode node2){
        if( node1.val != node2.val)
            return false;
        if( node1.left != null && node2.left != null){
            if( !isSame(node1.left,node2.left) )
                return false;
        }else if( node1.left == null && node2.left == null)
            ;
        else 
            return false;
        if( node1.right != null && node2.right != null){
            if( !isSame(node1.right,node2.right) )
                return false;
        }else if( node1.right == null && node2.right == null )
            ;
        else 
            return false;
        return true;
    }
    
    public TreeNode getAns(TreeNode root){
        
        TreeNode ans = new TreeNode(root.val);
        if( root.left != null )
            ans.left = getAns(root.left);
        if( root.right != null)
            ans.right = getAns(root.right);
        return ans;        
    }
    
    
    
    public void addNode(TreeNode root,int i ){
        while( true){
            if( i+1 > root.val ){
                if( root.right == null){
                    root.right = new TreeNode(i+1);
                    return ;
                }else
                    root = root.right;
            }else{
                if( root.left == null){
                    root.left = new TreeNode(i+1);
                    return ;
                }else
                    root = root.left;
            }
        }
    }
    public void delNote(TreeNode root,int i){
        while( true){
            if( i+1 > root.val ){
                if( i+1 == root.right.val ){
                    root.right = null;
                    return ;
                }else
                    root = root.right;
            }else{
                if( i+1 == root.left.val ){
                    root.left = null;
                    return ;
                }else
                    root = root.left;
            }
        }
    }
    
}

然后看了网上的解答，有两个我认为还不错，一个是根据树的结构来回溯，效率很高，不会出现重复，

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<TreeNode> generateTrees(int n) {
        
        if(n == 0) {
            return new ArrayList<TreeNode>();
        }
        
        return gen(1, n);
    }
    
    List<TreeNode> gen(int start, int end) {
        ArrayList<TreeNode> heads = new ArrayList<TreeNode>();
        if(start > end) {
            heads.add(null);
            return heads;
        }
        
        for(int i = start; i <= end; i++) {
            
            List<TreeNode> lefts = gen(start, i - 1);
            List<TreeNode> rights = gen(i + 1, end);
            
            for(TreeNode left : lefts) {
                for(TreeNode right : rights) {
                    TreeNode head = new TreeNode(i);
                    head.left = left;
                    head.right = right;
                    heads.add(head);
                }
            }
        }
        
        return heads;
        
    }
}

 还有一种动态规划其实也就是第二种方法的改良。

public static List<TreeNode> generateTrees(int n) {
    List<TreeNode>[] result = new List[n + 1];
    result[0] = new ArrayList<TreeNode>();
    if (n == 0) {
        return result[0];
    }

    result[0].add(null);
    for (int len = 1; len <= n; len++) {
        result[len] = new ArrayList<TreeNode>();
        for (int j = 0; j < len; j++) {
            for (TreeNode nodeL : result[j]) {
                for (TreeNode nodeR : result[len - j - 1]) {
                    TreeNode node = new TreeNode(j + 1);
                    node.left = nodeL;
                    node.right = clone(nodeR, j + 1);
                    result[len].add(node);
                }
            }
        }
    }
    return result[n];
}

private static TreeNode clone(TreeNode n, int offset) {
    if (n == null) {
        return null;
    }
    TreeNode node = new TreeNode(n.val + offset);
    node.left = clone(n.left, offset);
    node.right = clone(n.right, offset);
    return node;
}