Sortieren mit Nur-Lese-Stapeln

Betrachten Sie die folgende Einstellung:

• Wir erhalten einen Stapel der Elemente enthält .$s$$n$
• Wir können eine konstante Anzahl von zusätzlichen Stapeln verwenden.$O(1)$
• Wir können die folgenden Operationen auf diese Stapel anwenden:
  1. Überprüfen Sie, ob ein Stapel leer ist.
  2. Vergleichen Sie die Top-Artikel von zwei Stapeln,
  3. lösche den obersten Gegenstand in einem Stapel,
  4. Drucke den obersten Gegenstand in einem Stapel,
  5. Kopieren Sie das oberste Element eines Stapels in einen anderen Stapel.
  6. Kopieren Sie den Inhalt eines Stapels auf einen anderen Stapel.

Beachten Sie, dass dies die einzigen Operationen sind, die zulässig sind. Wir können keine Gegenstände tauschen und wir dürfen keine Gegenstände auf einen der Stapel schieben, mit Ausnahme des Kopierens des obersten Gegenstands in einen Stapel (danach wird der vorherige Inhalt des Zielstapels verworfen und enthält nur den kopierten Gegenstand). .

Hier ist ein Algorithmus zum Sortieren der Stapel mit -Vergleichen:$O(n^2)$

last := empty
for i from 1 to n
  min := empty
  w := s
  while w is not empty
    if w.top > last and w.top < min
      min := w.top
    delete w.top
  print min
  last := min

Können wir es besser machen?

Gibt es ein Programm, das die sortierte Liste der Elemente in den Stapeln nur mit -Vergleichen druckt ?$O(n\log n)$

Ich denke, ich kann jetzt eine nichttriviale Untergrenze demonstrieren. Die Idee ist, ein solches Programm mit einer Familie von Vergleichsverzweigungsprogrammen zu implementieren. Die "Nur-Lese" -Annahme bedeutet, dass unsere Familie von Verzweigungsprogrammen nur wenig Platz benötigt, dh . Dann wenden wir die untere Grenze S T = Ω ( n 2 ) an , die von Borodin et al. in "Ein Time-Space-Tradeoff für das Sortieren auf nicht vergessenen Maschinen." Dies gibt uns eine Untergrenze von n 2 / log n für die Zeit.$O(\log n)$$ST=\Omega(n^2)$$n^2/\log n$

Im Detail: Auf die obige Operation 5 können wir verzichten. Wenn wir schon die Köpfe zweier Listen vergleichen und den Kopf einer Liste ausdrucken können, brauchen wir den Kopf einer Liste nicht in einem bestimmten Register zu isolieren. Angenommen, wir sehen, dass jedes Register in der Maschine immer nur eine letzte Teilzeichenfolge der Eingabe speichert.

Angenommen, unser Registerprogramm hat Codezeilen und k Register, X 1 , … , X k .$\ell$$k$$X_1,\dots,X_k$

Fix . Wir konstruieren das Vergleichsverzweigungsprogramm für Zeichenketten der Länge n wie folgt. Erstellen Sie einen Knoten für jedes Tupel ( i , d 1 , … , d k ) mit 1 ≤ i ≤ ℓ und 0 ≤ d 1 , … , d k ≤ n . Die Idee ist, dass Berechnungen in der Registermaschine Pfaden im Verzweigungsprogramm entsprechen und wir uns am Knoten ( i , d 1 , … , $n$$n$$(i,d_1,\dots,d_k)$$1\le i\le \ell$$0\le d_1 ,\dots, d_k \le n$ , wenn wir anLinie sind i im Register Maschine und die Länge des Strings gespeichert in X i ist d i . Nun müssen wir die gerichteten Kanten des Verzweigungsprogramms definieren$(i,d_1 ,\dots, d_k)$$i$$X_i$$d_i$

Wenn Zeile von der Form ist$i$

wenn dann gehe zu i 1 sonst gehe zu i $X_u<X_v$$i_1$$i_2$

dann für all , den Knoten ( i , d 1 , ... , d k ) wird durch Vergleichen des markierten d u ' ten und d v -te Element der Eingabe, und die "wahren" edge gehen zu müssen , um ( i 1 , d 1 , … , d k ) und die "falsche" Kante zu ( i 2 , d 1 , … , d $d_1,\dots,d_k$$(i,d_1,\dots,d_k)$$d_u$$d_v$$(i_1,d_1,\dots,d_k)$ .$(i_2,d_1,\dots,d_k)$

Wenn Zeile von der Form ist$i$

, gehe zur Linie i $X_1 \leftarrow tail(X_2)$$i'$

dann gibt es einen Pfeil von einem beliebigen Knoten zu ( i ' , d 2 - 1 , … , d k ) .$(i,d_1,\dots,d_k)$$(i',d_2-1,\dots,d_k)$

Wenn Zeile von der Form ist$i$

, gehe zur Linie i $print(head(X_u))$$i'$

dann gibt es einen Pfeil von jedem Knoten bis ( i ' , d 1 , ... , d k ) , die durch den gekennzeichnet ist d u -ten Knoten des Einganges.$(i,d_1,\dots,d_k)$$(i',d_1,\dots,d_k)$$d_u$

Hoffentlich machen diese Beispiele deutlich, wie ich mein Verzweigungsprogramm aufbauen will. Wenn alles gesagt und getan ist , diese Verzweigung Programm hat höchstens Knoten, so dass es Raum hat O ( log n $\ell\cdot n^k$$O(\log n)$

Können Sie Elemente zählen? Dann, denke ich, gibt es eine ziemlich einfache Mergesort-Implementierung. Wenn Sie zusätzliche Symbole auf den Stapel legen könnten, könnten Sie dies mit 3 Stapeln wie folgt lösen:

Wenn wir nur ein Element haben, ist die Liste bereits sortiert. Nehmen wir nun an, wir haben die obere Hälfte des Stapels bereits sortiert. Wir können die obere Hälfte (in umgekehrter Reihenfolge) auf den zweiten Stapel kopieren und ein Trennsymbol darauf platzieren. Jetzt haben wir wieder 3 Stapel (da wir die bereits sortierten Symbole unterhalb des Trennsymbols ignorieren können) und können die untere Hälfte sortieren. Schließlich können wir die sortierte untere Hälfte in umgekehrter Reihenfolge auf einen dritten Stapel kopieren und beide Hälften wieder zum ursprünglichen Stapel zusammenführen.

Alle Operationen kosten lineare Zeit, daher haben wir die Liste in O ( n log n ) sortiert$O(n \log n)$

(Beachten Sie, dass wir aufgrund der Trennsymbole Stapel der Größe benötigen , dies kann jedoch leicht durch Verwendung eines anderen Stapels korrigiert werden.)$n \log n$

Da Sie keine neuen Elemente auf den Stapel legen können, können Probleme an den Trennungspunkten auftreten. Um dies zu lösen, können Sie mit einigen zusätzlichen Stapeln Folgendes tun:

$n-2^{\lfloor \log n\rfloor}$

$\log n$$c$$cn \log n+c\frac{n}{2} \log \frac{n}{2}+c\frac{n}{4} \log \frac{n}{4}+\ ... = O(n \log n)$$O(n \log n)$