Question

假设我必须通过合并两个BST来创建一个BST，其中T1和T2都是BST，这样T1的节点数多于T2，并且对于T2中的每个节点，从T2中删除节点并插入值节点进入T1，最后返回T1。读取其他帖子，这个算法的运行时似乎是O（m * log（n）），其中n是T1中的节点数，m是T2中的节点数。我不是100％确定为什么这会导致运行时复杂度。任何人都可以向我解释为什么它是O（m * log（n））？我的第一个猜测是O（m n），因为在迭代中，我们必须从T2中删除一个节点，这导致O（m）的运行时间，并且后续插入的运行时间为O（n）所以不应该是O（m n）？

Answer 1

您说二进制搜索树，不平衡二进制搜索树。并且，将值插入BST （二进制搜索树）的时间复杂度为：

最佳案例：O(log(n))。（当它完全平衡时）。
最坏情况：O(n)。

因为，我们正在将所有元素从T2 （最初有m个元素）移动到T1 （最初有n个元素）。因此，总的时间复杂度将是：

最佳案例：O(m.log(n))。
最坏情况：O(m.n)。

然而，实际上我们可以考虑平均时间复杂度，它将介于最佳和最差情况之间。

编辑：考虑一个澄清的案例。

T2            T1     # initial BST
#             #
8             3
 \             \
  9             4
   \             \ 
    10            5
     \             \
      11            6
                     \ 
                      7                       
m = 4      &   n = 5      (initial values).

Moving the 8 to the T1 from T2  
T2            T1    
#             #
9             3
 \             \
  10            4
   \             \ 
    11            5
                   \
                    6
                     \ 
                      7
                       \
                        8

Steps taken to insert 8 into its right place = 5 or (n)
Total Steps taken   = 5 or (n)

Moving the 9 to the T1 from T2  
T2            T1    
#             #
10            3
 \             \
  11            4
                 \ 
                  5
                   \
                    6
                     \ 
                      7
                       \
                        8
                         \
                          9

Steps taken to insert 9 into its right place = 6 or (n+1)
Total Steps taken   = 5+6  or (n) + (n+1)

Moving the 10 to the T1 from T2 
T2            T1    
#             #
11            3
               \
                4
                 \ 
                  5
                   \
                    6
                     \ 
                      7
                       \
                        8
                         \
                          9
                           \
                           10

Steps taken to insert 10 into its right place = 7 (n+2)
Total Steps taken   = 5+6+7 or (n) + (n+1) + (n+2) 

Moving the 11 to the T1 from T2 
T2            T1    
#             #
NULL          3
               \
                4
                 \ 
                  5
                   \
                    6
                     \ 
                      7
                       \
                        8
                         \
                          9
                           \
                           10
                             \
                             11

Steps taken to insert 11 into its right place = 8 (n+3)
Total Steps taken   = 5+6+7+8 or (n) + (n+1) + (n+2) + (n+3)

因此，通过观察我们可以说，在最坏的情况下，将m个值从T2移动到T1的步骤数量为：

=> (n) + (n+1) + (n+2) + .......   + (n + (m-1))
=> (n+n+n+...m times) + (1+2+3+....+(m-1))
=> (n.m) + (m.(m-1))/2

从那以后，n > m。因此，我们可以忽略加号后的第二个方程。

因此，时间复杂度：O(n.m)。

有效合并两个二进制搜索树并创建一个BST

1 个答案: