Sortieren mit einer Blackbox

Angenommen, wir wollen eine Liste von reellen Zahlen sortieren . Angenommen, wir erhalten eine Blackbox, mit der reelle Zahlen sofort sortiert werden können . Wie viel Vorteil können wir mit dieser Black Box gewinnen?n $S$$n$$\sqrt n$

Können wir zum Beispiel die Nummern mit nur Aufrufen an die Blackbox sortieren ? Der beste Algorithmus, den ich gefunden habe, verwendet Aufrufe an die Blackbox. Aber ich habe es nicht weiter verbessern können. Hier ist mein Algorithmus, der ähnlich wie Merge-Sort ist:$O(\sqrt n)$$n$

Teilen Sie zuerst die Liste in Listen mit ungefähr Größe auf. Verwenden Sie dann Aufrufe an die Blackbox, um diese Listen zu sortieren. Zum Schluss führen Sie die sortierten Listen mit der Blackbox wie folgt zusammen:$S$ s1,s2,. . . ,s$\sqrt n$$s_1, s_2, ..., s_{\sqrt n}$$\sqrt n$$\sqrt n$

Fügen Sie die kleinsten Elemente der Listen in eine neue Liste und rufen Sie die Blackbox auf, um sie zu sortieren. Die Zahl in (ersten und kleinstes Element ) wird die kleinste Zahl in seinem . Wir können es an die erste Stelle der Ausgabeliste setzen. Angenommen, das Element wurde aus , ersetzen wir durch das zweitkleinste Element der Sortierliste und führen erneut die Blackbox darauf aus, um das zweitkleinste Element von zu berechnen . Wir fahren fort, bis alle Elemente sortiert sind. Die Gesamtzahl der Blackbox-Anrufe für diesen Teil beträgtL [ 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$. Daher beträgt die Gesamtzahl der Anrufe insgesamt .$n$

Auf der anderen Seite sollten wir in der Lage sein, eine Untergrenze zu erhalten, indem wir die Untergrenze für die für die Sortierung erforderlichen Zahlenvergleiche wie folgt verwenden: Wir können die Blackbox mit implementieren. Vergleiche. Wenn wir das Problem mit Aufrufen an die Blackbox lösen und in linearer Zeit zusammenführen können, können wir reelle Zahlen mit Vergleichen sortieren, was unmöglich ist.o($\sqrt n \lg \sqrt n = \frac{1}{2} \sqrt n \lg n$no(nlgn$o(\sqrt n)$$n$$o(n \lg n)$

Ich denke, wir könnten beweisen, dass eine Untergrenze für die Anzahl der Aufrufe der Blackbox ist, da viele Vergleiche, die in der Blackbox verwendet werden, geteilt würden und daher in unserem Argument wiedergegeben werden.$\Omega(n)$

UPDATE: Wie die anderen Posts andeuten, ist auch ein erreichbar.$\sqrt n \lg n$

Es ist möglich mit O ( √ zu sortierenAnrufe an die Blackbox und keine Vergleiche.$O(\sqrt n\log n)$

Betrachten Sie zunächst das folgende Problem der ausgeglichenen Partitionierung: gegebene Elemente A [ 1 .. m ] (wobei $m$$A[1..m]$), unterteilen Sie diese in zwei Gruppen, von denen die kleinste mindestens etwam/4beträgt, so dass alle Elemente in der ersten Gruppe kleiner sind als alle Elemente in der zweiten Gruppe. Dies kann mitO(m/$\sqrt n \le m \le n$$m/4$ruft die Blackbox an. (Das beschreibe ich später.) Dann benutze quicksort mit diesem Partitionierungsalgorithmus:$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.

Angenommen, jeder Partitionsschritt benötigt Aufrufe an die Blackbox, dem obigen Algorithmus, gegebenen EingangA[1 ..n], machenO($O(m/\sqrt n)$$A[1..n]$ruft die Blackbox auf, weil der Rekursionsbaum die TiefeO(logn) hatund jede Ebene des Baums insgesamtO(n/$O(\sqrt n\log n)$$O(\log n)$ruft die Blackbox an.$O(n/\sqrt n) = O(\sqrt n)$

Führen Sie den Partitionierungsschritt wie folgt aus:

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.)

Ich denke, Ihre Frage wurde in Beigels und Gills Artikel " Sortieren von n Objekten mit dem K-Sorter " aus dem Jahr 1990 angesprochen, und die Zusammenfassung des Artikels sagt schon alles:

Ein k-Sorter ist ein Gerät, das k Objekte in Zeiteinheiten sortiert. Die Komplexität eines Algorithmus, der einen K-Sortierer verwendet, wird als die Anzahl der Anwendungen des K-Sortierers definiert. In dieser Maßnahme liegt die Komplexität des Sortierens von n Objekten zwischen und4nlog$\frac{n \log n}{k \log k}$ , bis zu Termen erster Ordnung in n und k.$\frac{4n \log n}{k \log k}$

Es ist möglich , zu sortieren obliviously mit ruft die Blackbox auf, die jeweils auf ein zusammenhängendes Subarray der ursprünglichen Eingabe angewendet wird. Der Algorithmus berührt die Eingabedaten nur durch Blackbox-Aufrufe. Insbesondere ist die gleiche Folge von Black-Box-Aufrufen nur eine Funktion vonn, nicht die tatsächlichen Eingangsdaten (daher "ahnungslos").$O(\sqrt{n}\log n)$$n$

Hier ist eine Skizze eines einfacheren Algorithmus, der eine Blackbox verwendet, die Subarrays der Größe anstelle von nur √ sortiert$k$ . Die Gesamtzahl der Anrufe an die Black Box beträgt ungefähr2(n/k)2. Zur Vereinfachung der Darstellung sei angenommen, dasskgerade und2n/keine ungerade ganze Zahl ist.$\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])

Hier ist ein Diagramm des Algorithmus für und k = 4 . Die Daten werden von links nach rechts übertragen. jede box ist ein k- sorter.$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)$