如何有效地合并两个 BST？答案

【问题标题】：How to merge two BST's efficiently?如何有效地合并两个 BST？
【发布时间】：2010-11-03 18:10:24
【问题描述】：

如何合并两个保持BST属性的二叉搜索树？

如果我们决定从树中取出每个元素并将其插入到另一个中，则此方法的复杂度将是O(n1 * log(n2))，其中n1 是树的节点数（比如T1），我们已经分裂了，n2 是另一棵树的节点数（比如T2）。在这个操作之后，只有一个 BST 有n1 + n2 节点。

我的问题是：我们能比 O(n1 * log(n2)) 做得更好吗？

【问题讨论】：

将树 1 的根插入树 2 并非在所有情况下都有效。
您假设所有二叉搜索树都是平衡的。（例如伸展树不是）另外我认为你的复杂性略有下降。因为 n2 正在增加，所以当您插入值时，树会变得更深。也许 (n1 + n2) / 2 是一个更好的近似值（因为在插入的开头，插入的时间是 O(log n2)，最后是 O(log(n1 + n2))。
@Evan Teran, ah union bf 例如，它们的范围 [a,h] 和 [b,f] 重叠，因此不能插入作为叶节点进入另一个

标签： c++ algorithm data-structures merge binary-search-tree

【解决方案1】：

如何将两棵树展平为排序列表，合并列表然后创建一个新树？

【讨论】：

正如其他人在我的帖子后指出的那样，这个过程的复杂性是 O(n1+n2)。例如，请参阅 yairchu 对我的回答的阐述。
您的帖子和@yairchu 之间的无限重定向循环。

【解决方案2】：

将树扁平化为排序列表。
合并排序列表。
从合并列表中创建树。

IIRC，即 O(n1+n2)。

【讨论】：

【解决方案3】：

Naaff 的回答更详细：

将 BST 扁平化为排序列表是 O(N)
- 这只是对整个树的“按顺序”迭代。
- 两者都做 O(n1+n2)
将两个排序列表合并为一个排序列表是 O(n1+n2)。
- 保留指向两个列表头部的指针
- 选择较小的头部并推进其指针
- 这就是合并排序的合并工作原理
从排序列表创建完美平衡的 BST 是 O(N)
- 请参阅下面的代码 sn-p 了解算法[1]
- 在我们的例子中，排序列表的大小为 n1+n2。所以 O(n1+n2)
- 生成的树将是二进制搜索列表的概念 BST

三步O(n1+n2)的结果是O(n1+n2)

对于相同数量级的n1和n2，这比O(n1 * log(n2))要好

[1] 从排序列表创建平衡 BST 的算法（在 Python 中）：

def create_balanced_search_tree(iterator, n):
    if n == 0:
        return None
    n_left = n//2
    n_right = n - 1 - n_left
    left = create_balanced_search_tree(iterator, n_left)
    node = iterator.next()
    right = create_balanced_search_tree(iterator, n_right)
    return {'left': left, 'node': node, 'right': right}

【讨论】：

无法改进的证明草图：您需要考虑每个元素。在树 1 中的 2 个相邻值之间，可能会在树 2 中找到 0,1 个或更多值。仅查看 N1+N2 个元素已经花费了 O(N1+N2) 时间。
@MSalters：根据 OP，您可以就地修改一棵树。您不必查看正在修改的树的所有元素
我很难理解创建平衡 BST 的最后一步是 O(N)。由于这里使用的数据结构是一个列表，在递归的每一级为 n 个元素找到“中间”的复杂性不是 n/2 吗？所以创建平衡 BST 的总复杂度是 n/2 log n，对吧？如果排序后的数据在一个数组中，我可以看到如何在 O(N) 中完成。但这里不是这样。我错过了什么？
@KarthikM：我的解释确实不太准确，现在将带有实际代码sn-p的算法添加到答案中。

【解决方案4】：

乔纳森，

排序后，我们有一个长度为 n1+n2 的列表。用它构建二叉树需要 log(n1+n2) 时间。这与归并排序相同，只是在每个递归步骤中，我们不会像归并排序算法那样拥有 O(n1+n2) 项。所以时间复杂度是log(n1+n2)。

现在整个问题的复杂度是O(n1+n2)。

另外，如果两个列表大小相当，我会说这种方法很好。如果大小无法比较，那么最好将小树的每个节点都插入到大树中。这将花费 O(n1*log(n2)) 时间。例如，如果我们有两棵树，一棵大小为 10，另一棵大小为 1024。这里 n1+n2 = 1034 其中 n1log(n2) = 10*10 = 100。所以方法必须取决于两棵树的大小。

【讨论】：

我的意思是用排序列表构建一棵树的复杂度为 log(n1+n2)。现在整个问题的复杂度是O(n1+n2)

【解决方案5】：

O(n1 * log(n2)) 是平均情况，即使我们有 2 将任何未排序的列表合并到 BST 中。我们没有利用列表是排序列表或 BST 的事实。

据我所知让我们假设一个 BST 有 n1 个元素，另一个有 n2 个元素。现在将一个 BST 转换为 O(n1) 中的排序数组列表 L1。

合并的 BST(BST, Array)

如果 (Array.size == 0) 返回 BST 如果（数组大小 ==1）在 BST 中插入元素。返回 BST；

在数组中找到左元素=BST.rootnode 的数组中的索引。 if(BST.rootNode.leftNode ==null ) //即没有左节点 { 将 Index 到 0 的所有数组插入 BST 的左侧，然后 } 别的 { 合并 BST(BST.leftNode, Array{0 to Index}) }

if(BST.rootNode.rightNode ==null)//即没有右节点 { 将 Index 到 Array.size 的所有数组插入 BST 的右侧 } 别的 { 合并 BST(BST.rightNode, Array{Index to Array.size}) }

返回 BST。

此算法将花费

【讨论】：

【解决方案6】：

这个想法是使用迭代的中序遍历。我们为两个 BST 使用两个辅助堆栈。由于我们需要以排序形式打印元素，所以每当我们从任何树中获得较小的元素时，我们都会打印它。如果元素更大，则我们将其推回堆栈以进行下一次迭代。

【讨论】：

双迭代中序遍历可以工作，但是你对打印出元素有什么看法？你应该以 BST 结束。