Optimale Sortieralgorithmen

Optimale Sortieralgorithmen
Gerold Jäger
12. Oktober 2003

Problem
• Für n ∈ N sei S(n) die minimale Anzahl von Vergleichen,
die benötigt wird, um n Elemente zu sortieren.
• Bestimme S(n).
S(n) ≤
Obere Schranke
� �
n
2
= n(n − 1)
2
(ergibt sich aus dem trivialen Sortier-Algorithmus,
bei dem man jedes Element mit jedem anderen
vergleicht)
1

Lineare Erweiterung
Sei M = {1, · · · , n} und r eine Halbordnung auf M.
Die Anzahl der möglichen Ordnungen O mit H ⊆ O
bezeichnet man als lineare Erweiterung e(r).
Beispiele: Man lasse die reflexiven Beziehungen weg.
e(∅) = n!
e((1, 2)) = n!
2
e((1, 2),(3, 4)) = n!
4
e((1, 2),(1, 3)) = n!
3
e((1, 2),(2, 3),(1, 3)) = n!
6
2

Untere Schranke
Für 1 ≤ i �= j ≤ n und r ′ := r ∪ (i, j) und r ′′ :=
r ∪ (j, i) gilt:
e(r) = e(r ′ ) + e(r ′′ )
Wegen e(∅) = n! und max{e(r ′ ),e(r ′′ )} ≤ e(r)
2 folgt:
S(n) ≥ ⌈log 2 n!⌉
3

Algorithmus: binäres Einsortieren
Seien die ersten k−1 Elemente schon sortiert. Das k-te
Element ak wird einsortiert, indem man es mit einem
mittleren Element aller noch nicht mit ak verglichenen
Elemente vergleicht.
Beispiel:
1
2
3
I III II
Man benötigt ⌈log 2 k⌉ Schritte zum Einsortieren.
4
6
5
7
8
4

Algorithmus von Ford, Johnson
(Verfeinerung des binären Einsortierens)
• Vergleiche jeweils zwei neue Elemente, bis ein oder
kein Element übrig ist.
• Es ergeben sich zwei Gruppen. Für ungerades n
nimm das übrige Element zur Gruppe der kleineren
Elemente hinzu.
• Sei n = 2m bzw. n = 2m + 1.
• Sortiere die m größeren Elemente, indem man dieses
Verfahren induktiv von n auf m überträgt.
• Das Einsortieren der n − m kleineren Elemente geschieht
auf folgende Weise (Beispiel n = 19):
5

5
6
J
7
I
8
H
9
G
3
F
Idee: Das Einsortieren in 2 k − 1 Elemente ist
optimal.
4
E
1
D
2
C
A
B
6

n US(n) S(n) FJ(n) BE(n)
1 0 0 0 0
2 1 1 1 1
3 3 3 3 3
4 5 5 5 5
5 7 7 7 8
6 10 10 10 11
7 13 13 13 14
8 16 16 16 17
9 19 19 19 21
10 22 22 22 25
11 26 26 26 29
12 29 30 30 33
13 33 34 34 37
14 37 38 38 41
15 41 ? 42 45
16 45 ? 46 49
17 49 ? 50 54
18 53 ? 54 59
19 57 ? 58 64
20 62 62 62 69
21 66 66 66 74
22 70 71 71 79
23 75 ? 76 84
24 80 ? 81 89
25 84 ? 86 94
47 198 ≤ 200 201 219
7

Sortierbarkeits-Algorithmus
Algorithmus SORT(r,c)
EINGABE M = {1, · · · ,n}, r Halbord. auf M, c ∈ N
(Algorithmus berechnet, ob r [insbesondere für r = ∅]
in c Schritten sortierbar ist)
1 IF e(r) ≤ 2
2 RETURN Sortierbar
3 FOR i = 1, · · · , n − 1
4 FOR j = i + 1, · · · ,n
5 IF (i, j) /∈ r AND (j,i) /∈ r
6 r1 := r ∪ {(i, j)}
7 r2 := r ∪ {(j, i)}
8 IF e(r1) ≤ 2 c−1 AND e(r2) ≤ 2 c−1
9 IF SORT(r1,c−1) AND SORT(r2, c−1)
10 RETURN Sortierbar
11 RETURN Nicht Sortierbar
Nachteile:
• rekursiver Algorithmus ⇒ sehr langsam
• viele r1, r2 werden sowohl bei der Berechnung der
Anzahl der linearen Erweiterungen als auch beim
rekursiven Aufruf von SORT mehrfach getestet
8

Wells Nicht-Sortierbarkeits-Algorithmus
Algorithmus NON-SORT(r,c)
EINGABE M = {1, · · · ,n}, r0 Halbord. auf M, c ∈ N
(Algorithmus versucht zu beweisen, dass r0 insbesondere
für r0 = ∅] nicht in c Schritten sortierbar ist)
1 S0 = {r0}
2 FOR k = 1, · · · , c
3 Sk = ∅
4 FOR EACH r ∈ Sc−1
5 FOR i = 1, · · · , n − 1
6 FOR j = i + 1, · · · ,n
5 IF (i, j) /∈ r AND (j,i) /∈ r
6 r1 := r ∪ {(i, j)}
7 r2 := r ∪ {(j, i)}
8 IF ! ISOM(r1, Sk) AND ! ISOM(r2, Sk)
(Ist r1/r2 zu einem r ′ ∈ Sk isomorph?)
9 IF e(r1) ≤ 2 c−k AND e(r2) ≤ 2 c−k
10 IF e(r1) ≥ e(r2)
11 Sk = Sk ∪ {r1}
12 ELSE
13 Sk = Sk ∪ {r2}
9

14 IF Es gibt eine geordnete Menge in Sc
15 Kein Ergebnis
16 ELSE
17 Nicht sortierbar
Wells Algorithmus benötigt:
Ullmans Algorithmus zum Aufspüren von Graphenisomorphismen
Algorithmus zur Berechnung der Anzahl der linearen
Erweiterungen
Wells Algorithmus liefert:
Für n = 12 ist r0 = ∅ nicht in 29 Schritten sortierbar.
⇒ S(12) = 30
10

Peczarskis Verbesserungen
• Effizientere Implementation
• Verbesserter Algorithmus zur Berechnung der Anzahl
der linearen Erweiterungen
• Neue Idee: Falls der Algorithmus kein Ergebnis liefert,
kann man auf folgende Weise testen, ob auch
in diesem Fall r0 nicht sortierbar ist:
– Wende den Sortierbarkeits-Algorithmus für k =
c − 1, · · · , 1 (soweit der Algorithmus Ergebnisse
liefert) auf alle r ∈ Sk an.
– Falls es ein k = c − 1, · · · , 1 gibt, so dass keine
Menge aus Sk in c − k Schritten sortierbar ist,
dann ist r0 nicht sortierbar.
• Neue Ergebnisse:
S(13) = 34,S(14) = 38,S(22) = 71
11

Sortierbarkeit oder Nicht-Sortierbarkeit
• Frage: Ist für n ∈ N r = ∅ in c Schritten sortierbar?
• Notwendige Bedingung:
e(r) = n! ≤ 2 c
• Für k = 1, · · · , c muss nach dem k-ten Sortierschritt
für die beiden möglichen neuen Halbordnungen r1
und r2 mit e(r) = e(r1) + e(r2) gelten:
max{e(r1), e(r2)} ≤ 2 c−k
• Je größer der Quotient n!
2 c ist, desto mehr kann man
die Nicht-Sortierbarkeit erwarten und desto schneller
ist der Nicht-Sortierbarkeits-Algorithmus fertig.
12

Fälle, für die 2 mögliche S(n) in Frage
kommen
n 12 13 14 15 16 17
n!
2 ⌈log 2 n!⌉ 0.89 0.72 0.63 0.59 0.59 0.63
n 18 19 22 23 24
n!
2 ⌈log 2 n!⌉ 0.71 0.84 0.95 0.68 0.51
Berechnung weiterer Werte von S(n)
• Wells und Peczarskis Nicht-Sortierbarkeits-
Algorithmus liefert nur negative Resultate:
– S(12) > 29 ⇒ S(12) = 30 (Wells)
– S(13) > 33 ⇒ S(13) = 34 (Peczarski)
– S(14) > 37 ⇒ S(14) = 38 (Peczarski)
– S(22) > 70 ⇒ S(22) = 71 (Peczarski)
• Vermutung: S(16) = 45 < 46 = FJ(16)
• Solche verbesserten Algorithmen können nur mit
dem (zu langsamen) Sortierbarkeits-Algorithmus
nachgewiesen werden.
⇒ Verbesserter Sortierbarkeits-Algorithmus!
13

Verbesserter Sortierbarkeits-Algorithmus
Algorithmus NEW-SORT(r,c)
EINGABE M = {1, · · · ,n}, r Halbord. auf M, c ∈ N
(Algorithmus berechnet, ob r [insbesondere für r = ∅]
in c Schritten sortierbar ist)
Ideen des Algorithmus
• Man betrachte c Stufen 0, · · · , c − 1.
• In Stufe k betrachte man Halbordnungen, die in
c − k Schritten sortierbar sind.
• Für jede Halbordnung r ′ in jeder Stufe k gibt es drei
Zustände:
sortierbar=2, nicht sortierbar=1, undefiniert=0.
• Zum Durchführen von Isomorphietests und somit
zum Vermeiden doppelter Berechnungen speichern
wir alle Zwischenergebnisse der Art:
14

′ (in Stufe k) ist in c − k Schritten (nicht)
sortierbar.
• Stufe 0 hat am Anfang den Zustand 0. Hat diese
Stufe den Zustand 2, so ist r sortierbar. Hat sie den
Zustand 1, so ist r nicht sortierbar.
• Wir benutzen folgende Beobachtung:
r ′ ist in k Schritten sortierbar.
⇔ Es gibt 1 ≤ i < j ≤ n, so dass r ′ ∪ {(i, j)}
und r ′ ∪ {(j, i)} in k − 1 Schritten sortierbar sind
• In jeder Stufe außer 0 werden zwei Halbordnungen
betrachtet.
15

• Folgende Zustände sind denkbar:
a) (0, 0) oder (2,0) (bzw. (0) in Stufe 0)
∗ Erhöhe die Stufe um 1.
∗ Addiere zu r ′ aus der letzten Stufe ein noch
nicht betrachtetes Paar (i, j).
∗ Mögliche Zustände in der neuen Stufe:
· (0,0): Keine Informationen.
· (1,0), (2,0), (2, 1),(2, 2): Informationen durch
Isomorphietests.
b) (1, 0) oder (2,1)
∗ Verringere die Stufe um 1.
∗ Mögliche Zustände in der neuen Stufe:
· (0,0), (2,0): Man kann noch weitere Paare
testen.
· (1,0), (2,1) (bzw. (1) in Stufe 0): Man hat
alle Paare getestet.
c) (2, 2)
∗ Verringere die Stufe um 1.
∗ Mögliche Zustände in der neuen Stufe:
· (2,0): Man muss noch das umgekehrte Paar
testen.
16

· (2,2) (bzw. (2) in Stufe 0): Man hat beide
Paare getestet.
d) (0, 1), (0,2)
· Nicht möglich, da definitionsgemäß das erste
Paar immer zuerst betrachtet wird.
e) (1, 1), (1,2)
· Nicht möglich, da wenn ein Paar keine sortierbare
Halbordnung liefert, das umgekehrte
Paar nicht mehr betrachtet werden muss.
• Weiter wird benutzt, dass eine Halbordnung r ′ in
1 Schritt sortierbar ist, genau dann wenn e(r ′ ) ≤ 2
ist.
Vorteile im Vergleich zum
Original-Algorithmus
• Nicht-rekursiver Algorithmus.
• Durch Isomorphietests Vermeiden von doppelten
Rechnungen.
17