构造所有可能的BST

问题描述

给定 1 到 N 的数字序列，你需要构造出所有可能的平衡二叉搜索树 (BST)。

解决方案

我们可以使用递归的方式来解决这个问题。由于要构造所有可能的 BST ，所以我们可以考虑遍历每个数字作为根节点，将其分为左子树和右子树，递归地构建它们。最后将它们组合起来。

我们可以使用如下的递归函数：

def generate_bst(start, end):
    if start > end:
        return [None]
    res = []
    for i in range(start, end+1):
        left_trees = generate_bst(start, i-1)
        right_trees = generate_bst(i+1, end)
        for left in left_trees:
            for right in right_trees:
                root = TreeNode(i)
                root.left = left
                root.right = right
                res.append(root)
    return res

该函数的参数 start 和 end 表示序列的开始和结束位置。当 start > end 时，我们返回一个只包含 None 的节点列表。

否则，对于该区间内的每个数字 i，我们都递归地生成以 i 为根节点的左子树和右子树。然后，我们通过将根节点与左子树、右子树组合，生成一棵完整的子树。最终的结果就是这些子树的全部组合。

代码实现

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


def generate_bst(start, end):
    if start > end:
        return [None]
    res = []
    for i in range(start, end+1):
        left_trees = generate_bst(start, i-1)
        right_trees = generate_bst(i+1, end)
        for left in left_trees:
            for right in right_trees:
                root = TreeNode(i)
                root.left = left
                root.right = right
                res.append(root)
    return res


def inorder_traversal(root):
    if root is None:
        return []
    return inorder_traversal(root.left) + [root.val] + inorder_traversal(root.right)


if __name__ == '__main__':
    N = 3
    trees = generate_bst(1, N)
    for i, tree in enumerate(trees):
        print(f"Tree {i+1} inorder traversal:", inorder_traversal(tree))

其中，inorder_traversal 函数用于输出 BST 的中序遍历结果，以验证生成结果的正确性。

示例输出

Tree 1 inorder traversal: [1, 2, 3]
Tree 2 inorder traversal: [1, 3, 2]

复杂度分析

该算法的时间复杂度为 $O(n^2)$，其中 $n$ 是数字序列的长度。当数字序列足够大时，该算法的效率可能会较低，因此可能需要进行相应的优化。

算法的空间复杂度是 $O(n)$。因为每个节点都需要存储，所以需要的空间取决于二叉树的深度和其节点数。但是，由于是平衡二叉树，所以树高度与节点数的关系是 $h = log_2(n)$，所以空间复杂度与节点数成正比，即为 $O(n)$。