3. Sortieren - Universität Tübingen

3. Sortieren
Beispiel für Analyse von Verfahren und gleichzeitig
„eine Art, Datenmengen zu verwalten“.
Sortieren: eine Folge so permutieren, dass sie aufsteigend
geordnet ist.
13,7,11
7,11,13
Motivation: 25% aller Rechnerzeit wird für Sortieren
verbraucht.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
1
3.1 Sortieren durch Auswahl:
Eingabe: 11,3,6,7,6,12
Ausgabe: 3,6,6,7,11,12
Jeweils Minimum suchen, ausgeben, streichen
1.) Wie repräsentieren wir Ein- und Ausgabefolgen?
Benutzen z.B. Felder A und B:
i-tes Ein- und Ausgabeelement in A[i] bzw. B[i].
2.) Was bedeutet es, eine Zahl zu streichen?
Benutzen weiteres Feld:
Rem: array [1...n] of boolean
Rem[i] = true bedeutet, dass A[i] durchgestrichen ist.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
2
3.) Wie bestimmen wir die Position des Minimums?
function Posofmin: integer;
var i, pos : integer
begin i ← 1;
while Rem[i] do i ← i+1;
pos ← i;
for i = 1 to n do
if (A[i] < A[pos]) and not Rem[i]
then pos ← i;
Posofmin ← pos;
end
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
3
Wenn wir nicht Zahlen sortieren, sondern beliebige
Elemente eines bestimmten Typs, so ersetzen wir
(A[i] < A[pos]) durch lessthan (A[i], A[pos]),
wobei
function lessthan (x,y : typ): boolean
geeignet definiert werden muss.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
4
Sortieren durch Auswahl
for i ← 1 to n do Rem[i] := false;
for i ← 1 to n do
begin j ← posmin;
B[i] ← A[j];
Rem[j] ← true
end;
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
5
Elegantere und platzeffizientere Lösung
86376
3|6 8 7 6
3 6|8 7 6
3 6 6|7 8
3 6 6 7|8
36678
for i ← 1 to n do
begin j ← posmin (i,n);
(* posmin liefert Minimum von A[i],...,A[n] *)
exchange (A[i], A[j]);
end;
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
6
3.2 Quicksort
(Sortieren durch Teilen)
Wende „Teile- und Beherrsche“-Prinzip an.
Eingabe: Feld S mit Werten x1, x2, ..., xn
Idee
1. Teile S-{x1} bzgl. x1 in 2 Mengen A,B
(Teile)
A = {xi | i ≥ 2 und xi ≤ x1 }, sei A = j
B = {xi | i ≥ 2 und xi > x1 }
Speichere A in S[1]...S[j]
x1 in S[j+1]
B in S[j+2]...S[n]
x1
A
j j+1
B
2. Wende Verfahren rekursiv auf A und B an.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
(Beherrsche)
7
Implementierung:
Füge S [0] = −∞ und S [n + 1] = +∞ zu S hinzu.
Dies erspart einige Tests.
Teil 1: Teile
i ← 2 ; j ← n ; k ← S[1] ;
repeat while S [i ] ≤ k do i ← i+1 ;
while S [ j ] > k do j ← j-1 ;
if i ≤ j then vertausche (S[i], S[j])
i ← i+1 ; j ← j-1 ;
fi
until i > j ;
Vertausche (S[1], S[j])
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
8
Analyse: Kosten = Anzahl der Vergleiche zwischen S[i]‘s.
Kosten im schlechtesten Fall:
Kosten eines Aufrufs Quicksort (l,r) sind
a) unmittelbare Kosten bei Teile-Schritt O(r-l+1) Vergleiche
b) Kosten der rekursiven Aufrufe
Sei QS(n) = max. Anzahl von Vergleichen, die Quicksort
an Feld der Länge n durchführt.
Es gilt:
QS (n ) = O(n) + max{ QS ( j − 1) + QS (n − j )}
424
3 1424
3
1≤ j ≤ n 1
QS (0) = QS (1) = 0.
Vorlesung Algorithmen (RN/MK/AZ)
rek. Aufruf für A
für B
WSI für Informatik, Universität Tübingen
9
Behauptung:
n
QS (n ) = ∑ i ≤
i=2
( )
1
n(n + 1) = O n 2
2
Beweis: durch Induktion
Bemerkung: An Eingabe 1, 2, 3, ..., n führt Quicksort
wirklich O(n2) Vergleiche durch. Obere Schranke
ist also scharf.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
10
Kosten im Mittel:
Annahmen:
1. Elemente von S sind paarweise verschieden.
2. Jede der n! möglichen Permutationen der Eingabe ist
gleich wahrscheinlich.
Damit können wir o.B.d.A. annehmen, dass die Schlüssel
die Zahlen 1, 2, ..., n sind und dass S[1] = k ist mit
Wahrscheinlichkeit 1/n für 1 ≤ k ≤ n.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
11
Dann müssen rekursiv Teilprobleme der Größe k-1 und
n-k gelöst werden.
Diese Teilprobleme sind wieder zufällige Folgen,
d.h. sie erfüllen Annahmen 1.) und 2.).
(Beweis: entfällt, siehe Literatur)
Sei QS (n ) die mittlere Anzahl der Vergleiche, die
Quicksort an einem Feld der Größe n durchführt.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
12
QS (0) = QS (1) = 0
(
)
und QS (n ) = n + " Erwartungswert QS ( A) + QS (B ) "
(
)
1 n
= n + ∑ QS (k − 1) + QS (n − k )
n k =1
2 n −1
= n + ∑ QS (k )
n k =0
n −1
n ⋅ QS (n ) = n 2 + 2∑ QS (k )
k =0
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
13
und
(n + 1)QS (n + 1) = (n + 1)
2
n
+ 2∑ QS (k )
k =0
Dann:
(n + 1)QS (n + 1) − nQS (n ) = (n + 1)2 − n 2 + 2QS (n )
= 2n + 1 + 2QS (n )
(n + 1)QS (n + 1) = 2n + 1 + (n + 2)QS (n )
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
14
⇒
n+2
QS (n + 1) ≤ 2 +
QS (n )
n +1
n+2
n +1
n

(2 + ...) 
= 2+
 2 +
2 +
n +1 
n 
n −1

2
2
 2

= 2 + (n + 2)
+ +
+ K + 1
 n +1 n n −1


1
1 
 1
= 21 + (n + 2)
+ + K +  .
2 
 n +1 n

Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
15
d.h.
n
1

 n 1 
QS (n ) ≤ 21 + (n + 1)∑  = 2 + 2(n + 1) ∑ − 1
i=2 i 

 i =1 i 
n
1
= 2 + 2(n + 1)∑ − 2(n + 1)
i =1 i
n
1
= 2(n + 1)∑ − 2n
i =1 i
≤ 2(n + 1)(1 + ln n ) − 2n
= O(n log n )
Satz: Die mittlere Laufzeit von Quicksort ist O(n log n).
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
16
3.3 Heapsort
(Sortieren durch Auswahl)
Heap ist Datenstruktur, die folgende Operationen
unterstützt:
• function
Emptyheap : heap;
liefert Heap mit Wert ø.
• procedure
Insert (x: item, var h: heap);
verändert „Wert“ von h durch Einfügen von x
• function
Extractmin (var h: heap): item;
verändert Wert von h durch Streichen des Minimums
und liefert gestrichenes Element.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
17
Heapsort:
h ← Emptyheap;
for i = 1 to n
do Insert (A[i], h);
for i = 1 to n
do B[i] ← Extractmin (h);
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
18
Zur Realisierung von Heaps:
Ein binärer Baum ist entweder leer oder er besteht aus einem
Knoten, der Wurzel genannt wird, und einem rechten und
linken Teilbaum.
Bsp.:
u
v
w
x
u ist die Wurzel, v die Wurzel des linken Teilbaums von u, ...
v = Kind von u, u = Elternknoten von v, x ist ein Blatt.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
19
Sei u ein Knoten in einem Baum T.
 0, falls u die Wurzel ist
Tiefe(u) := 
 Tiefe(Elternknoten(u)) +1, sonst
Bsp.: Tiefe(w) = 1
 0, falls u ein Blatt ist
Höhe(u) := 
 max{Höhe(v) | v ist Kind von u} +1, sonst
Bsp.: Höhe(w) = 2
Tiefe(T) := max {Tiefe(u) | u ist Knoten in T}
Höhe(T) := max {Höhe(u) | u ist Knoten in T}
= Höhe(Wurzel(T))
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
20
(Binäre) Heaps lassen sich durch Binärbäume darstellen:
Bsp.: {1, 2, 3, 4, 5} darstellbar durch
1
5
1
2
4
2
oder
3
oder ...
3
4
5
Jeder Baumknoten u ist mit einem Element S[u] beschriftet.
Zusätzlich fordern wir die „Heap-Eigenschaft“:
Ist u Elternknoten von v, so ist S [u ] ≤ S [v ]
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
21
Realisierung der Heap-Operationen:
• function Emptyheap:
klar!
• function Extractmin:
Minimumsbestimmung: Min. steht an der Wurzel
Minimumsentfernung: Baum muss „reorganisiert“ werden
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
22
Bsp.:
2
Reorg. I
6
8
10
⇒
4
11
10
6
15
6
8
4
11
6
15
13
13
I) Beliebiges Blatt wird entfernt und an die Wurzel gesetzt.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
23
II) danach wird durch sukzessives Vertauschen mit dem
kleinsten Kind die Heap-Eigenschaft wiederhergestellt:
4
Reorg. II
⇒
8
6
4
Reorg. II
⇒
10
11 6
15
6
8
6
11 10
13
Vorlesung Algorithmen (RN/MK/AZ)
15
13
WSI für Informatik, Universität Tübingen
24
procedure Insert: Einzufügendes Element an Knoten anhängen,
welcher höchstens ein Kind hat.
Danach Vertauschen mit Elternknoten, falls
dieser größer ist usw.
Bsp.: Einfügen des Elements 5:
4
6
8
⇒
6
11 10
5
4
⇒
6
15
8
13
Vorlesung Algorithmen (RN/MK/AZ)
6
11 5
10
4
6
15
13
8
11 6
5
10
WSI für Informatik, Universität Tübingen
15
13
25
Ausgewogene Bäume:
Es gibt k ≥ 0, sodass
1. Alle Blätter haben Tiefe k oder k+1 und
2. Blätter der Tiefe k+1 sitzen „ganz links“.
Bsp.:
1
2
4
3
5
6
8
7
Nummerierung der Knoten:
Nummeriere Knoten der Höhe
nach und innerhalb jeder Höhe
von links nach rechts.
9 10
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
26
Dann gilt:
(1) Hat ein Knoten Nummer i > 1, so hat sein Elternknoten
die Nummer i / 2 .
(2) Hat ein Knoten Nummer i, so haben seine Kinder
(falls existent) die Nummern 2i und 2i+1.
⇒
Darstellung ausgewogener binärer Baum durch Paar (A,n),
wobei n Anzahl der Knoten und A Array, sodass A[i]
Beschriftung des Knotens mit Nummer i ist für alle i = 1, ..., n.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
27
Beispiel:
1
16
2
14
4
8
2
8
7
4
9
1
5
9
10
6
3
3
7
10
A: 16 14 10 8 7 9 3 2 4 1
1 2 3 4 5 6 7 8 9 10
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
28
Zur Implementierung von Heapsort:
type heap = record
A: array [1...N] of item;
<*N hinreichend groß*>
n: integer;
end
function Emptyheap : heap;
var h: heap;
begin
h.n ← 0; <*keine Elemente*>
Emptyheap ← h
end
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
29
procedure Insert (x: item; var h: heap);
var i,j: integer;
finish: boolean;
begin
h.n ← h.n +1; <*ein Element mehr*>
i ← h.n
h.A[i] ← x; <*neues, „linksbündiges“ El.*>
finish ← (i = 1);
while not finish do
begin
j ← i div 2 <*j Elternknoten von i*>
if h.A[i] < h.A[j]
then Interchange (h.A[i], h.A[j])
else finish ← true;
i ← j;
if finish = false then finish ← (i=1);
end
end
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
30
Zur Laufzeit-Analyse von Heapsort:
Heapsort besteht i.w. aus je n Aufrufen von Insert und
Extractmin.
„Leicht“ sieht man:
Ausführungszeit von Insert und Extractmin ist
O(Höhe des Baumes)
Lemma:
Hat ein ausgewogener Baum die Höhe m, so enthält er
mindestens 2m und weniger als 2m+1 Knoten.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
31
Nun gilt:
2 m ≤ n ⇒ m − 1 ≤ log n 
Wir erhalten Laufzeit =
O(n ⋅ m ) = O(n ⋅ (log n  + 1)) = O(n log n ).
Bemerkungen:
• Obwohl Heapsort im Gegensatz zu Quicksort sogar im Worst
Case Laufzeit O(n log n) hat, ist Quicksort in der Praxis
meist überlegen.
• Für „vergleichsbasierte Sortierverfahren“ läßt sich die untere
Schranke Ω(n log n ) beweisen, Heapsort ist in diesem
Sinne also asymptotisch optimal. Diese untere Schranke
gilt auch im Durchschnitt (bei Gleichverteilung).
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
32
3.4 Mergesort
(Sortieren durch Mischen)
Bisher betrachtete Sortierverfahren:
Daten im Hauptspeicher.
Für externe Speichermedien, aber andere Sortierverfahren
vorteilhaft, z.B. Sortieren durch Mischen:
Füge zwei (oder mehrere) sortierte Folgen zu einer
sortierten Folge zusammen.
Z.B.
11 6 6 5 3
12 8
Vorlesung Algorithmen (RN/MK/AZ)
5
12 11 8
6
6
WSI für Informatik, Universität Tübingen
5
5
3
33
Mischalgorithmus:
Start mit leerer Ausgabefolge
Solange mind. eine Eingabefolge nichtleer,
- bestimme x = min A, wobei A die Menge der ersten
Elemente der nichtleeren Eingabefolgen ist,
- entferne x aus Eingabefolge, wo es vorkommt und
- füge es ans Ende der Ausgabefolge.
Korrektheit: x ist nicht nur das Minimum über A, sondern
über der Menge aller verbleibenden
Eingabeelemente ...
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
34
Zum Sortierverfahren:
Bezeichne aufsteigend sortierte Teilfolgen als „Runs“.
Grundprinzip:
Teile Eingabe in Teilfolgen der Länge 1 (das sind Runs).
Mische danach Runs zu längeren Runs.
Bsp.: Eingabe: 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5
(1) Streuphase:
3, 4, 5, 2, 5, 5
3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5
1, 1, 9, 6, 3
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
35
(2) Mischphase:
345255
13 59 35
11963
14 26 5
1134 355
11234569
2569
355
11233455569
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
36
Beobachtung:
Nach i-tem Durchlauf haben alle Runs
Länge ≤ 2i .
Allgemeiner: pi für p = # Eingabedateien
= # Ausgabedateien
Wenn p i ≥ n, so ist die Eingabe sortiert.
Also genau logp n Durchläufe nötig.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
37
Effizienzverbesserung:
Annahme: Hauptspeicher habe Platz für m Elemente (p < m < n).
Dann können wir Durchläufe sparen, indem wir interne
Sortierverfahren dazu benutzen, anfangs Runs der Länge m
zu erstellen.
Bsp.: m = 3
3 1 4 1 5 9 2 6 5 3 5
113 459
235 56
Vorlesung Algorithmen (RN/MK/AZ)
134 256
159 35
11233455569
WSI für Informatik, Universität Tübingen
38
Analyse:
Nach i Durchläufen haben die Runs Länge m·2i (bzw. m·pi).
n

Also genügen log p  Durchläufe.
m

Bsp.: n = 107, m = 104, p = 3
⇒ 7 Durchläufe
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
39
3.5 Bucketsort
(Sortieren durch Fachverteilung)
Betrachte oBdA Alphabet Σ = {1, 2, ..., m}
Für die Wörter x = x1 ... xk und y = y1 ... yr ∈ Σ*
sagen wir, dass x kleiner als y (x < y) ist,
genau dann, wenn
∃i, 0 ≤ i ≤ k ∀j, 1 ≤ j ≤ i: x j = y j und
entweder i = k < r
oder i < k und i < r und xi+1 < yi+1.
Ziel: Wörter über dem Alphabet Σ bzgl. der gegebenen
Ordnung sortieren.
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
40
Spezialfall 1: Alle n Wörter haben Länge 1.
Lösungsansatz: Stelle m Fächer bereit und gehe die n Zahlen
durch und wirf jede Zahl in das ihrem Wert gemäße
Fach.
Implementierung der Fächer z.B. als lineare Listen und ein
Feld der Größe m zum Speichern der Listenköpfe.
Gesamtzeitaufwand: O(n + m)
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
41
Spezialfall 2: Alle n Wörter haben gleiche Länge k.
Schreibweise: i-tes Wort: xi = x1i x2i ... xki
Vorteilhaft, zunächst nach dem k-ten Symbol zu sortieren,
dann nach dem (k-1)-ten, usw.
Damit k „Läufe“ über die Menge der Wörter.
Jeder Lauf gemäß Spezialfall 1
Laufzeit O((n + m) ·k)
⇒
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
42
Bsp.: 123 , 124, 223, 324, 321
m = 4, n = 5, k = 3
1. Lauf
321
2. Lauf
3. Lauf
223
123
124
123
Vorlesung Algorithmen (RN/MK/AZ)
324
124
223
123
321
223
324
124
324
321
WSI für Informatik, Universität Tübingen
43
Wie vermeiden wir Aufwand mit leeren Fächern?
Sei sj die Anzahl der im j-ten Lauf nichtleeren Fächer.
Ziel: Aufsammeln im j-ten Lauf in O(sj) Schritten
und damit Aufwand j-ter Lauf O(sj + n).
Erzeuge n·k Paare (j, xj i), 1 ≤ i ≤ n, 1 ≤ j ≤ k
und sortiere durch Fachverteilung zunächst nach der zweiten
und dann nach der ersten Komponente.
Nach 2. Lauf liegen im j-ten Fach gerade alle Buchstaben
in sortierter Reihenfolge, die an der j-ten Stelle vorkommen.
Aufwand 1. Lauf: O(n·k + m)
Aufwand 2. Lauf: O(n·k + k)
Σ : O(n·k + m)
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
44
Allgemeiner Fall: n Wörter beliebiger Länge
n
|xi| =: ri , L := ∑ li , lmax := maxi {li}
i =1
Beachte: x i nicht „zu früh“ in Fachverteilung miteinbeziehen;
erst bearbeiten, wenn nach dem li-ten Buchstaben
sortiert wird.
(
Sortiere Wörter zunächst der Länge nach ...)
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
45
Algorithmus:
1 Bestimme li ∀i und erzeuge Paare (li, Verweis auf xi)
2 Sortiere (li, Verweis auf xi) durch Fachverteilung nach
1. Komponente. Bezeichne Länge[k] die Liste der Elemente
der Länge k.
3 Erzeuge L Paare (j, xji), 1 ≤ i ≤ n, 1 ≤ j ≤ ri und
sortiere sie nach der 2. und dann der 1. Komponente.
2. Fachverteilung liefert lineare Listen Nichtleer[j],
1 ≤ j ≤ lmax . Lösche Duplikate aus Nichtleer[j].
4 Sortiere nun die Wörter xi durch Fachverteilung wie oben
beschrieben (unter Berücksichtigung von Länge[k]).
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
46
Eine einfache Analyse zeigt:
Satz:
Sortieren durch Fachverteilung sortiert n Wörter
der Gesamtlänge L über einem Alphabet der
Größe m in Zeit O(m + L).
Anwendung: Sortieren n reeller Zahlen x1, ...,xn
Vereinfachung: Betrachte reelle Zahlen xi (0,1] mit 1 i
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
n:
47
3.6 Hybridsort
α ∈ R fest, k := α ⋅ n
1 Schaffe k leere Körbe. Wirf xi in den Korb
k ⋅ xi  für 1 ≤ i ≤ n
2 Wende Heapsort auf jeden Korb an und konkateniere
die Körbe, d.h. reihe sie hintereinander auf.
Mitteilung:
1. Worst Case Laufzeit von Hybridsort ist O(n log n).
2. Wenn xi unabhängig gemäß Einheitsverteilung aus (0,1]
gewählt, dann hat Hybridsort mittlere Laufzeit O(n).
Vorlesung Algorithmen (RN/MK/AZ)
WSI für Informatik, Universität Tübingen
48