LeetCode刻意练习23--不同的二叉搜索树

给定一个整数 n，生成所有由 1 … n 为节点所组成的二叉搜索树。

思路：

二叉排序树是左子树的值均小于根节点，右子树的值均大于根节点，而且左右子树也是二叉排序树。

因此，当我们选择第 i 个结点作为根节点时，第1-（i-1）个结点是左子树，第（i+1)到n个结点时右子树。

如果 1-（i-1）个结点可以形成 x 棵不同的子树，
（i+1）-n 个结点可以形成 y 棵不同的子树，
那么第 i 个结点作为 根结点的二叉排序树的数目一共有 x * y 棵；

而我们一共有 N 个不同的结点作为根节点。

所以我们可以通过迭代 1-n 作为树的根节点，
然后再去循环左右子树。

How to construct all BST for keys 1…N?
The idea is to maintain a list of roots of all BSTs. Recursively construct all possible left and right subtrees. Create a tree for every pair of left and right subtree and add the tree to list. Below is detailed algorithm.

1. 创建一个放二叉排序树的列表. list
2. 对每一个 i 做下列动作：
   a.创建一个新结点，将 i 赋给他的值val
   b.递归地构造左子树
   c.递归地构造右子树
   3)遍历所有左子树
   对于当前左子树，遍历所有右子树，将左右子树添加到 treenode，将treeNode添加到放二叉树的列表 list

  public List<TreeNode> generateTrees(int n) { 
        if(n==0)
        {
            List<TreeNode> list=new LinkedList<>();
            return list;
        }
        return constructTrees(1,n);
    }

    public List<TreeNode> constructTrees(int start, int end) {
        List<TreeNode> list = new LinkedList<>();

        if (start > end) {
            list.add(null);
            return list;
        }


        for (int i = start; i <= end; i++) {
       
            List<TreeNode> leftSubtree = constructTrees(start, i - 1);        
            List<TreeNode> rightSubtree = constructTrees(i + 1, end);


            for (int j = 0; j < leftSubtree.size(); j++) {
                TreeNode left = leftSubtree.get(j);
                for (int k = 0; k < rightSubtree.size(); k++) {
                    TreeNode right = rightSubtree.get(k);
                    TreeNode TreeNode = new TreeNode(i);        
                    TreeNode.left = left;             
                    TreeNode.right = right;            
                    list.add(TreeNode);                 
                }
            }
        }
        return list;
    }