Сортировка по черному ящику

Предположим, что мы хотим отсортировать список из действительных чисел. Предположим, что нам дан черный ящик, который может мгновенно отсортировать реальных чисел. Какое преимущество мы можем получить, используя этот черный ящик?n $S$$n$$\sqrt n$

Например, можем ли мы отсортировать номера только с помощью вызовов в черный ящик? Лучший алгоритм, который я нашел, использует вызовов черного ящика. Но я не смог улучшить его дальше. Вот мой алгоритм, который похож на сортировку слиянием:$O(\sqrt n)$$n$

Сначала разбейте список на списков примерно с размером. Затем используйте вызовов черного ящика для сортировки этих списков. Наконец, объедините отсортированные списки, используя черный ящик следующим образом:$S$ ы1,ев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$

С другой стороны, похоже, что мы должны быть в состоянии получить нижнюю границу, используя нижнюю границу для сравнения чисел, необходимых для сортировки, следующим образом: Мы можем реализовать черный ящик, используя сравнений. Если мы сможем решить эту проблему с помощью вызовов в черный ящик и слияния в линейное время, мы можем отсортировать действительных чисел с помощью сравнений, что невозможно.o($\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]$), разделите их на две группы, наименьший размер которых должен составлять не менееm/4, чтобы все элементы в первой группе были меньше, чем все элементы во второй группе. Это можно сделать с помощьюO(m/$\sqrt n \le m \le n$$m/4$звонки в черный ящик. (Я опишу это позже.) Затем используйте быструю сортировку с этим алгоритмом разделения:$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.)

Я думаю, что ваш вопрос был рассмотрен в статье Бейгеля и Джилла " Сортировка n объектов с использованием k-sorter " от 1990 года, и реферат статьи говорит сам за себя:

$\frac{n \log n}{k \log 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$

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