leetcode95 不同的二叉搜索树II

给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。
示例 1：

输入：n = 3
输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
示例 2：

输入：n = 1
输出：[[1]]

链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
  public List<TreeNode> generateTrees(int n) {
        if(n==0) return new ArrayList<TreeNode>();
        return dfs(1,n);
    }
    public ArrayList<TreeNode> dfs(int start,int end)
    {
        ArrayList<TreeNode>  ans=new ArrayList<>();
        if(start>end)
        {
            ans.add(null);
            return ans;
//            return null;//这样做不正确，因为上层会在遍历的时候出现空指针
        }

        for(int i=start;i<=end;i++)
        {
//            TreeNode root=new TreeNode(i);
//            ans.add(root);//不能在这
            ArrayList<TreeNode> leftAarr=dfs(start,i-1);
            ArrayList<TreeNode> rightArr=dfs(i+1,end);
            for(TreeNode l:leftAarr)
            {
                for(TreeNode r:rightArr)
                {
                    TreeNode root=new TreeNode(i);
                    ans.add(root);
                    root.left=l;
                    root.right=r;
                }
            }
        }
        return ans;

    }
}

一个错误的示例，为什么错误？？由于树与子树的根节点一直在变化，而没有创建新的所以会出现错误

public class seqecStack {

    List<TreeNode> ans=new ArrayList<>();

    public List<TreeNode> generateTrees(int n) {
        if(n==0) return ans;
        HashSet<Integer> usedSet=new HashSet<>();
        for(int i=1;i<=n;i++)
        {
            TreeNode head=new TreeNode(i);
            usedSet.add(i);
            dfs(head,head,usedSet,n);
            usedSet.remove(i);
        }
        return ans;
    }
    public void dfs(TreeNode head,TreeNode root,HashSet<Integer> usedSet,int n)
    {
        if(n<=usedSet.size())
        {
            TreeNode newHead=new TreeNode(head.val);
            newHead.left=head.left;
            newHead.right=head.right;
            ans.add(newHead);
            return;
        }
        for(int i=1;i<=n;i++)
        {
            if(usedSet.contains(i)||i>=root.val) continue;
            root.left=new TreeNode(i);
            usedSet.add(i);
            dfs(head,root.left,usedSet,n);
            usedSet.remove(i);
        }
        for(int j=1;j<=n;j++)
        {
            if(usedSet.contains(j)||j<root.val) continue;
            root.right=new TreeNode(j);
            usedSet.add(j);
            dfs(head,root.right,usedSet,n);
            usedSet.remove(j);
        }

    }
    public static void main(String[] args) {
        new seqecStack().generateTrees(3);
    }

}