分裂和克服k-way-merge算法的时空复杂性

Question

假设A是k个数组的数组。 每个内部数组都已排序并包含m个元素。

鉴于此算法用于合并A：

中保存的K排序数组

// A is array of sorted arrays  
K-arrays-merge(A)   
1.  if A.length == 1
2.      return first element of A
3.  half = length[A] / 2
4.  firstHalfArray = new array[half][m];
5.  secondHalfArray = new array[half][m];
6.  for (i = 0; i < half; i++)
7.      do firstHalfArray[i] = A[i];
8.  for (i = half; i < length[A]; i++)
9.      do secondHalfArray[i] = A[i];
10. secondHalfArray = Copy second half arrays from A
11. a = K-arrays-merge(firstHalfArray)
12. b = K-arrays-merge(secondHalfArray)
13. return merge(a,b) // This is a merge between two sorted arrays with time complexity of O(n)

为什么这个算法的时间复杂性是O（m * klogk）？

我的第一个想法是递归方法运行logk次，在每一轮复制数组是O（m * k），合并排序是O（mi log（mi））其中1 <= i <= logk

看着分而治之的步骤：

1. 除以 - 计算中间点为O（1），复制数组为O（mk）
2. 征服 - 2T（k / 2） - 递归通话。
3. 合并 - 合并排序的复杂度为O（m i log（m i））1 <= i <= logk。

我不知道如何计算时间复杂度。此算法的空间复杂度又是什么？

Answer 1

如果我们使用n = mk，则时间复杂度为T(k) = 2T(k/2) + n + n。 n用于数组副本，n用于合并，2T(k/2)用于递归调用。因此，算法的时间复杂度为O(nlog k) = O(mk log(k))。

每次数组的所有值都复制并存储在堆栈中，并且堆栈深度为O(log k)时，空间复杂度为O(n log k) = O(mk log k)。