Zusammenfassung 3

Algo&Komp. - Wichtige Begriffe
Mattia Bergomi 2008
Woche 4−5
1
Binäre Suche
Wenn wir ein Element x in einem Array der Länge n suchen, sollten wir natürlich n
Vergleiche durchführen, aber wenn das Array schon sortiert ist, dann brauchen wir in
der Tat sehr viel weniger Operationen.
Um das Element x in einem sortierten Array A der Länge n zu finden, operiert Binäre
Suche folgendermassen:
• Vergleiche x mit A( n2 ): falls x < A( n2 ), dann wird der Teil A( n2 , . . . , n)
überflüssig,somit
betrachten wir nur noch
die andere Hälfte des Arrays. Analog
für x > A( n2 ) und den Teil A(1, . . . , n2 ).
• Wir wiederholen diese Prozedur, bis x gefunden wird oder keine Elemente mehr
übrig sind.
Die Laufzeit ist O (log(n)).
x
x
...
a
n 2
Abbildung 1: Binäre Suche, graphisch erklärt
2
Sortieralgorithmen
Die Aufgabe ist hier, eine gegebene Array der Länge n (d.h. mit n Elementen, die
Zahlen ∈ R sind) aufsteigend zu sortieren. Bevor wir die Algorithmen präsentieren,
bemerken wir das folgende Theorem:
Theorem Jeder Sortieralgorithmus, der “if”-Abfragen benutzt, benötigt mindestens
Ω (n log(n)) Vergleiche.
Das heisst, alle Algorithmen, welche die Elemente miteinander vergleichen (if A[3] <
A[7] then . . . ) , können nicht schneller als Θ (n log(n)) sein.
-1-
Algo&Komp. - Wichtige Begriffe
2.1
Mattia Bergomi 2008
MergeSort
Die Idee ist die folgende (vergleiche Abbildung 2.1):
• “Zerlege” das Array so, dass es nur aus einzelnen Elemente besteht, und betrachte die Paare (A[1], A[2]), (A[3], A[4]), . . .
• Sortiere jedes Paar (triviale Aufgabe) und kriege n/2 sortierte Blöcke.
• Betrachte jetzt die Paare (Block1 , Block2 ), (Block3 , Block4 ), . . . und sortiere
jedes Paar von Blöcken folgendermassen: vergleiche nur die erste Elementen
der Blöcke und nimm das kleinste, lösche es aus dem zugehörigen Block und
wiederhole, bis die zwei Blöcke leer sind (vergleiche Abbildung 2.1, Teil unten
rechts).
• Wir haben jetzt n/4 sortierte Blöcke der Grösse 4. Wiederhole den letzten Schritt
oben, bis wir die ganze (sortierte) Sequenz (der Länge n) bekommen.
Die Laufzeit ist O (n log(n)).
7
7
7
2
5
2
5
1
5
2
2
7
1
8
1
6
4
8
3
6
8
1
5
3
6
3
8
4
3
4
6
4
Ersten vergleichen
2
1
7
5
3
4
8
6
Ersten vergleichen
1
2
5
7
2
3
3
4
6
6
7
8
8
Ersten vergleichen
1
4
5
Abbildung 2: MergeSort, graphisch erklärt
2.2
QuickSort
Die Idee ist die folgende (vergleiche Abbildung 2.2):
• Wähle (zufällig, z.B. das erste Element) ein Pivot-Element.
• Zerlege das Array in zwei Blöcke:
Block1 := {Elemente kleiner als der Pivot},
Block2 := {Elemente grösser als der Pivot}.
-2-
min {3, 4} = 3
min {8, 4} = 4
min {8, 6} = 6
min {8, ∅} = 8
Algo&Komp. - Wichtige Begriffe
Mattia Bergomi 2008
• Betrachte jetzt diese zwei Blöcke separat und wiederhole die Prozedur (wähle
Pivot, zerlege in zwei Unterblöcke, usw.) bis alle Blöcke Grösse 1 haben: das
Resultat (“von links nach rechts gelesen”) ist dann die sortierte Sequenz.
Die Laufzeit ist (im Durchschnitt, da zufällige Wahl des Pivots) O (n log(n)).
Pivot (zufällig)
2
2
7
2
5
1
3
4
5
3
4
5
3
4
5
1
1
2
1
8
7
3
6
4
7
8
6
6
8
7
8
6
Abbildung 3: QuickSort, graphisch erklärt
2.3
BucketSort
Dieser Algorithmus ist ein Beispiel, wo Theorem 1 nicht anwendbar ist. In der Tat
vergleicht dieser Algorithmus nie zwei Zahlen im Array miteinander, aber wir müssen
voraussetzen, dass alle Elemente aus (o.B.d.A.) {1, . . . , N } kommen. Das Sortieren ist
dann einfach: wir zählen wie oft das Element 1 erscheint, wie oft das Element 2 usw.,
und am Ende geben wir als Resultat die Elemente {1, . . . , N } mit der zugehörigen
Multiplizität aus.
Die Laufzeit ist O (n + N ).
3
3
1
3
1
4
2
3
1
4
2
1
1
1
2
2
3
3
3
3
4
4
Abbildung 4: BucketSort, graphisch erklärt
-3-
Algo&Komp. - Wichtige Begriffe
3
Mattia Bergomi 2008
Select (Median)
Das Ziel ist das k-te kleinste Element eines Arrays A zu bestimmen. Insbesondere ist
für k = n2 das Resultat der Median von A.
Man könnte das Array (trivialerweise) einfach sortieren und dann das k-te Element
lesen, aber wir können auch viel schneller zum Resultat kommen.
Die Idee von Select ist die folgende (vergleiche Abbildung 3):
• Teile A in n5 Gruppen von je 5 Elementen (die letzte Gruppe wird i.a. weniger
als 5 Elemente enthalten, aber das ist kein Problem).
• Sortiere jede dieser Gruppen und schreibe sie als Spalten in eine Tabelle. Die
dritte Zeile dieser Tabelle enthält alle Mediane der Gruppen.
• Sortiere jetzt die Spalten so, dass die Mediane auf der dritten Zeile aufsteigend
sortiert sind (d.h. links steht die Gruppe mit dem kleinsten Median, usw.).
• Bestimme jetzt den Median M der dritten Zeile (d.h. den Median der Mediane).
Nehme an er steht in der m-ten Spalte.
• Wenn wir am k-ten kleinsten Element interessiert sind und m > k gilt, so können
wir natürlich alle Elemente grösser als M verwerfen. Dies sind genau jene, die
in der grauen Fläche der Abbildung liegen (analog für m ≤ k).
• Iteriere, bis das Problem klein genug wird (z.B. sagen wir ≤ 15 Elemente), wo
wir dann das Problem “manuell” lösen können (d.h. sortiere und lese das k-te
Element).
Die Laufzeit ist O (n).
m-te Spalte
...
M
Alle ≥ M ⇒ Lösche
Gruppe 5 Gruppe 7
Abbildung 5: Select, graphisch erklärt
-4-