计算生成相同二叉搜索树的给定数组的排列

对于给定的数组，我们可以通过其构建出唯一确定的二叉搜索树。因此，我们也可以通过已知的二叉搜索树来推断出原始数组的排列方式。

算法

可以使用递归算法来实现此目的。具体来说，我们选择二叉搜索树中的任意一个元素作为根节点，然后递归地构建其左子树和右子树。

过程

• 对于递归过程的基本情况，当给定的二叉搜索树为空时，只有一种排列，即空数组。
• 对于递归过程中的任何一次调用，我们都会将根作为一组答案中的元素，然后递归地计算左子树的所有排列和右子树的所有排列。

根据组合数学的知识，左子树产生的排列数与右子树产生的排列数相乘就得到了当前树给出的答案。

代码

下面是一份 python 实现的参考代码：

def permute(nums):
    if not nums:
        return [[]]

    ans = []
    for i in range(len(nums)):
        left_perms = permute(nums[:i])
        right_perms = permute(nums[i+1:])

        for l in left_perms:
            for r in right_perms:
                ans.append([nums[i]] + l + r)

    return ans

def generate_trees(n):
    if n == 0:
        return []
    return generate_trees_helper(1, n)

def generate_trees_helper(start, end):
    if start > end:
        return [None]

    ans = []
    for i in range(start, end+1):
        for l in generate_trees_helper(start, i-1):
            for r in generate_trees_helper(i+1, end):
                node = TreeNode(i)
                node.left = l
                node.right = r
                ans.append(node)

    return ans

def find_permutations(n):
    trees = generate_trees(n)
    ans = []
    for t in trees:
        ans += permute(tree_to_arr(t))
    return ans

def tree_to_arr(root):
    if not root:
        return []
    return [root.val] + tree_to_arr(root.left) + tree_to_arr(root.right)

性能

时间复杂度取决于二叉搜索树的排列数量，即卡特兰数。对于不同的输入，时间复杂度可以从线性级别到超过指数级别不等。而空间复杂度则为线性级别，即取决于返回的排列数量。

参考文献

• 卡特兰数（Catalan Numbers）
• Leetcode: Unique Binary Search Trees II