Question

我需要建议一种算法，它采用BST（二进制搜索树），T1具有2^(n + 1) - 1个密钥，并构建一个具有相同密钥的AVL树。该算法应该在最差和平均时间复杂度方面有效（作为n的函数）。

我不确定我该怎么办呢。很明显，具有2^(n + 1) - 1密钥的BST的最小尺寸为n（如果它是完整/平衡的，则会是这种情况），但它对我有何帮助？

有一种直接的方法是迭代树，每次将T1的根添加到AVL树，然后从T1中删除它：

由于T1可能无法平衡，因此删除可能会在最坏的情况下花费O（n）
插入AVL将花费O（log n）
有2^(n + 1) - 1

总而言之，这将花费O(n*logn*2^n)，这非常昂贵。

但我为什么要从T1删除？我在那里支付了很多，没有充分的理由。所以我想为什么不在T1上使用树遍历，并且对于我正在访问的每个节点，将其添加到AVL树中：

有2^(n + 1) - 1个节点，因此遍历将花费O(2^n)（每次访问每个节点）
每次将当前节点添加到AVL将花费O(logn)

所以总共会花费O(logn * 2^n)。这是我能想到的最好的时间复杂性，问题是，它能以更快的方式完成吗？在O(2^n)中？将插入到AVL树的某种方式仅花费O（1）？

我希望我很清楚，我的问题属于这里。

非常感谢，

诺姆

Answer 1

有一种平衡BST并在线性时间内运行的算法Day Stout Warren Algorithm

基本上它所做的就是通过进行有序遍历（O（n））将BST转换为有序数组或链表。然后，它递归地获取数组的中间元素，使其成为根，并使其子元素分别成为左和右子数组的中间元素（O（n））。这是一个例子，

       UNBALANCED BST
            5
          /   \
         3     8
              / \
             7   9
            /     \
           6      10


        SORTED ARRAY
      |3|5|6|7|8|9|10|

现在这里是递归调用和结果树，

 DSW(initial array)

             7
 7.left = DSW(left array) //|3|5|6|
 7.right = DSW(right array) //|8|9|10|

             7
            / \
           5   9
 5.left = DSW(|3|)
 5.right = DSW(|6|)
 9.left = DSW(|8|)
 9.right = DSW(|10|)

             7
            / \
           5   9
          / \ / \
         3  6 8 10

用二叉搜索树构建AVL树

1 个答案: