6. Übung zu Algorithmen I 25. Mai 2016

6. Übung zu Algorithmen I
25. Mai 2016
Lisa Kohl
[email protected]
(mit Folien von Julian Arz, Timo Bingmann, Sebastian Schlag und
Christoph Striecks)
Organisatorisches
Erinnerung
I 1. Abschreiben: Verwarnung und 0 Punkte für die Aufgabe
I 2. Abschreiben: keine Bonuspunkte für die Klausur
Achtung
I Ab jetzt: Punktabzug für fehlendes Deckblatt und
fehlende Tutoriumsnummer!
Probeklausur
I Mittwoch, den 08.06., statt Vorlesung und Übung
Quicksort
Procedure qSort(a : Array of Element; `, r : N)
if ` ≥ r then return
k:= pickPivotPos(a, `, r )
m:= partition(a, `, r , k)
qSort(a, `, m − 1)
qSort(a, m + 1, r )
Quicksort
Partitionierung aus der Vorlesung
Function partition(a : Array of Element, `, r , k : N) : N
p:= a[k], i:= `, j:= `
swap(a[k], a[r ])
while j < r do
if a[j] ≤ p then
swap(a[i], a[j])
i ++
j ++
swap(a[i], a[r ])
return i
Quicksort
Alternative Partitionierung
Function dpartition(a : Array of Element, `, r , k : N) : N
p:= a[k], i:= `, j:= r
swap(a[k], a[i])
while i 6= j do
if i < j then
assert ∀t < i : a[t] ≤ p ∧ ∀t > j : a[t] > p
while a[j] > p and i 6= j do j − −
if i 6= j then swap(a[i], a[j]), swap(i, j), j + +
else
assert ∀t < j : a[t] ≤ p ∧ ∀t > i : a[t] > p
while a[j] ≤ p and i 6= j do j + +
if i 6= j then swap(a[i], a[j]), swap(i, j), j − −
return i
Dual Pivot Quicksort
I
Idee: partitioniere Eingabe in 3 Teile
I
Historisch:
[Sedgewick 1975], [Hennequin 1991]
⇒ keine Verbesserung durch Multi-Pivot-Ansatz in
Theorie und Praxis
I
2009: [Yaroslavskiy 2009]
I
I
praktisch & theoretisch besser
2011: Dual Pivot Quicksort wird Standard in Java 7
Dual Pivot Quicksort
1. wähle 2 Pivotelemente p ≤ q
2. klassifiziere Elemente in:
I
I
I
klein
mittel
groß
wenn
wenn
wenn
·<p
p≤·≤q
q<·
3. ordne alle Elemente entsprechend ihrer Klasse:
<p
p
p≤·≤q
q
4. sortierte die 3 Teilbereiche rekursiv
>q
Dual Pivot Quicksort
Partitionierung
Function dualpartition(a : Array of Element, `, r : N) : (N, N)
p:= a[`], q:= a[r ]
i:= ` + 1, j:= r − 1, k:= i
while k ≤ j do
if a[k] < p then swap(a[k], a[i]), i + +
else
if a[k] > q then
while a[j] > q and k < j do j − −
swap(a[k], a[j]), j − −
if a[k] < p then swap(a[k], a[i]), i + +
k ++
i − −, j + +
swap(a[`], a[i]), swap(a[r ], a[j])
return (i, j)
Dual Pivot Quicksort
Analyse
Hoare (1962): “Ur”-Quicksort
Average Case für 1 zufällig gewähltes Pivot
I
erwartete Vergleiche: 2n(Hn − 1) ≈ 2n loge n
Wild, Nebel (2012): “Yaroslavskiy”-Quicksort
Average Case für 2 zufällig gewählte Pivots
I
erwartete Vergleiche: 1.9n loge n − 2.46n + O(log n)
Ganzzahliges Sortieren
I
I
I
untere Schranke gilt nur für vergleichsbasiertes Sortieren!
Idee: verwende alternative Strategie für bessere Laufzeit
Beispiel: Bucket Sort
I
I
Annahme: Array enthält n ganze Zahlen im Intervall [1, k]
Sortieren möglich in O(n + k)!