使用黑匣子排序

假设我们想要一个列表排序，$S$的$n$实数。假设我们得到一个黑匣子，它可以立即对实数进行排序。使用这个黑匣子，我们可以获得多少优势？$\sqrt n$

例如，是否可以仅使用调用黑盒来对数字进行排序？我发现的最佳算法是对黑盒使用调用。但是我无法进一步改进它。这是我的算法，类似于merge-sort：$O(\sqrt n)$$n$

首先将列表划分为大小约为列表。然后使用调用黑盒对这些列表进行排序。最后，使用黑框合并排序列表，如下所示：$S$小号1，s ^2，。。。，ş$\sqrt n$$s_1, s_2, ..., s_{\sqrt n}$$\sqrt n$$\sqrt n$

将列表中的最小元素放入新列表，然后调用黑盒对其进行排序。在数（第一和的最小元素）将在最小数目。我们可以将其放在输出列表的第一位。 假设已从选择元素，我们将替换为排序列表的第二个最小元素，然后再次运行黑盒以计算的第二个最小成员。 我们继续进行，直到所有元素都被排序为止。此部分的黑匣子调用总数为L [ 1 ] L S s j L [ 1 ] s j S n - $L$$L[1]$$L$$S$
$s_j$$L[1]$$s_j$$S$
$n - \sqrt n$。因此，总的通话总数为$n$。

另一方面，看起来我们应该能够使用排序所需的数字比较中的下界来获得下界：我们可以使用√来实现黑盒$\sqrt n \lg \sqrt n = \frac{1}{2} \sqrt n \lg n$比较。如果我们可以通过调用来解决该问题，并在线性时间内进行合并，则可以使用比较对实数进行排序，这是不可能的。no（nlgn$o(\sqrt n)$$n$$o(n \lg n)$

我猜想我们可以证明是调用黑盒的次数的下限，因为黑盒中使用的许多比较将被共享，因此在我们的论点中被重新叙述。$\Omega(n)$

更新：正如其他帖子所建议的，也可以实现。$\sqrt n \lg n$

可以用调用黑框，不进行比较。$O(\sqrt n\log n)$

首先，考虑以下平衡分配问题：给定元素A [ 1 .. m ]（其中$m$$A[1..m]$），将它们划分成两组，最小尺寸为至少约的米/4，使得第一组中的所有元素是比所述第二组中的所有元素小。可以用O（m/$\sqrt n \le m \le n$$m/4$呼叫黑匣子。（稍后将对此进行描述。）然后对这种分区算法使用quicksort：$O(m/\sqrt n)$

def qsort(A[1..m]):
   if m < sqrt(n): sort A with one call to the black box
   else:
     Partition A[1..m] into two groups as described above.
     Recursively qsort the first group.
     Recursively qsort the second group.

假设每个分区步长为调用黑盒，在给定输入A[1 ..n]的情况下，上述算法将使O（$O(m/\sqrt n)$$A[1..n]$调用黑盒，因为递归树的深度为O（logn），并且树的每个级别的总深度为O（n/$O(\sqrt n\log n)$$O(\log n)$呼叫黑匣子。$O(n/\sqrt n) = O(\sqrt n)$

请按照以下步骤进行分区：

def partition(A[1..m]):  (where sqrt(n) <= m <= n)
   Divide A into m/sqrt(n) groups of size sqrt(n) each.
   Sort each group with one call to the black box per group.
   Sort the medians of the groups with one call to the black box.
   (Note the number of groups is less than sqrt(n), because m <= n.)
   Let X be the median of the medians.
   Partition all m elements around X, using the black box as follows:
      For each group G, let Y be its median:
        Call the black box once on (G - {Y}) union {X}.
        (This gives enough information to order all elts w.r.t. X.)

我认为您的问题在Beigel和Gill于1990年发表的论文“ 使用k- sorter 对n个对象进行排序 ”中得到了解决，该论文的摘要说明了一切：

k分类器是一种在单位时间内对k个对象进行分类的设备。使用k分类器的算法的复杂度定义为k分类器的应用次数。在这种情况下，对n个对象进行排序的复杂度在n log n之间和4nlog$\frac{n \log n}{k \log k}$，直到n和k中的一阶项。$\frac{4n \log n}{k \log k}$

$O(\sqrt{n}\log n)$$n$

$k$$\sqrt{n}$$2(n/k)^2$$k$$2n/k$

BlockBubbleSort(X[0..n-1], k):
   m = floor(n/k)
   for i = 1 to m
      for j = 0 to m-1
          BlackBoxSort(X[j*k .. (j+1)*k-1])
      for j = 0 to m-1
          BlackBoxSort(X[j*k + k/2 .. (j+1)*k + k/2 - 1])

$n=18$$k=4$$k$分拣机。

正如该图所希望的那样，该算法将输入数组分解成大小的块 $k/2$，然后使用 $k$-sorter in place of a compare-exchange operation. Correctness follows by observing that the network correctly sorts any array of 0s and 1s.

As @VinayakPathak's comment suggests, the $O((n/k)^2)$ bound can be reduced by replacing bubblesort with a different sorting network. For example, Batcher's even-odd mergesort reduces the number of black-box calls to $O((n/k)\log^2(n/k)) = O(\sqrt{n}\log^2 n)$, and the AKS sorting network reduces it to $O((n/k)\log (n/k)) = O(\sqrt{n}\log n)$. This last algorithm matches Neal's non-oblivious algorithm up to (large!!) constant factors.