力扣0095——不同的二叉搜索树II

不同的二叉搜索树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]]

题解

根据二叉搜索树的概念可以分析得到这是一个递归方法解决的问题

• 由n个节点组成的二叉搜索树的节点值范围为[$1,n$]，用 $rootValue$ 表示根结点值，则 $1\le rootValue\le n$，根节点左子树的范围为[$1,rootValue-1$]，根节点右子树的范围为[$rootValue-1,n$]
• 对于每一个根节点，左右子树有多种情况，可以是任意一个符合要求的子树
• 用[$start,end$]表示二叉搜索树的取值范围，终止条件为取值范围为空，当节点值不为空的时候分别将每个节点值作为根节点值，然后递归构造左右子树

最后将答案添加到列表中返回即可得到最终结果

想法代码

public class TreeNode
{
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int val = 0, TreeNode left = null, TreeNode right = null)
    {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
class Solution
{
    public static void Main(String[] args)
    {
        int n = 3;
        Solution solution = new Solution();
        IList<TreeNode> ans = solution.GenerateTrees(n);
        foreach (TreeNode node in ans)
        {
            IList<int> temp = solution.InorderTraversal(node);
            foreach (var a in temp)
            {
                Console.Write(a + " ");
            }
            Console.WriteLine();
        }
    }

    public IList<TreeNode> GenerateTrees(int n)
    {
        if (n == 0)
        {
            return new List<TreeNode>();
        }
        else
        {
            return CallBack(1, n);
        }

    }

    public List<TreeNode> CallBack(int start, int end)
    {
        List<TreeNode> ans = new List<TreeNode>();
        if (start > end)
        {
            ans.Add(null);
        }
        else
        {
            for (int i = start; i <= end; i++)
            {
                List<TreeNode> leftTrees = CallBack(start,i - 1);
                List<TreeNode> rightTrees = CallBack(i + 1,end);
                foreach (var a in leftTrees)
                {
                    foreach (var b in rightTrees)
                    {
                        TreeNode root = new TreeNode(i);
                        root.left = a;
                        root.right = b;
                        ans.Add(root);
                    }
                }
            }
        }
        return ans;
    }
    public IList<int> InorderTraversal(TreeNode root)
    {
        IList<int> ans = new List<int>();
        BackTrack(root, ans);
        return ans;
    }

    public void BackTrack(TreeNode root, IList<int> ans)
    {
        if (root == null)
        {
            return;
        }

        BackTrack(root.left, ans);
        ans.Add(root.val);
        BackTrack(root.right, ans);
    }
}
ack(root.left, ans);
        ans.Add(root.val);
        BackTrack(root.right, ans);
    }
}