4. Übung Algorithmen I

Transkript

1 Timo Bingmann, Christian Schulz INSTITUT FÜR THEORETISCHE INFORMATIK, PROF. SANDERS 1 KIT Timo Universität Bingmann, des LandesChristian Baden-Württemberg Schulz und nationales Forschungszentrum in der Helmholtz-Gemeinschaft Institut für Theoretische Informatik

2 Übungsklausur Üben des Stoffes und Übungspunkte für den Schein Termin: Montag, 3. Juni 15:45 Uhr (statt Vorlesung), Dauer 90min Bitte seien Sie pünktlich!! Einlass: 15:35 Uhr, Beginn: 15:45 Uhr Nachzügler bekommen keinen Zugang!! D.h.: Ab 15:45 Uhr ist die Tür zu! Hilfsmittel: 1 DIN A4 einseitig handbeschriebener Zettel Unterschrift für selbständige Anfertigung Tutoriumsnummer auf die Klausur schreiben 2 Timo Bingmann, Christian Schulz

3 Unbounded Hashtables 3 Timo Bingmann, Christian Schulz

4 Unbounded Hashtables Amortisierung Problem: Daten Stück für Stück in Hashtabelle einfügen Anzahl unbekannt Was passiert wenn eine Hashtabelle zu voll wird? Hashing with linear Probing: Überlauf Hashing mit verk. Liste: find und remove werden langsamer Lösung: Hashtabelle dynamisch vergrößern und verkleinern 4 Timo Bingmann, Christian Schulz

5 Unbounded Hashtables mit verketteten Listen Modifizierte Operationen find: keine Veränderung insert: Größe verdoppeln, bei #Slots Elemente remove: Größe halbieren, bei 1 4 #Slots Elemente Erinnert an unbeschränkte Arrays 5 Timo Bingmann, Christian Schulz

6 Unbounded Hashtables verketteten Listen Problem: Hashfuntion muss zur Tabellengröße passen Grund: Soll möglichst gleichverteilt streuen Nach Größenänderung nicht mehr der Fall Lösung: Bei Größenänderung neue Hashfunktion wählen Dann: vollständiger rehash D.h.: Elemente nicht nur kopieren, sondern neu einhashen 6 Timo Bingmann, Christian Schulz

7 Unbounded Hashtable verketteten Listen Laufzeit Laufzeit von insert, find, remove (exkl. rehash): Unverändert erwartet O(1) Laufzeit von rehash: Amortisiert O(1) Argumentation wie bei unbeschränkten Arrays D.h.: Bei insert und remove einzahlen aufs Konto 7 Timo Bingmann, Christian Schulz

8 Neue Hashfunktion wählen Beispiel Hashen von Zahlen h(x) = x mod Tabellengröße Problem: Wenn Tabellengröße = 2 k Entspricht: Extrahieren der k niedrigsten Bits D.h.: Nur k niedrigste Bits nehmen Einfluss Besser: Tabellengröße immer Primzahl Möglichst weit entfernt von Zweierpotenzen Implementierung: Primzahlentabelle, z.b. im Code Wähle bei Größenänderungen die nächstgrößere Primzahl aus Tabelle 8 Timo Bingmann, Christian Schulz

9 Rehash Beispiel insert: 22, 42, 9, 25, 18 und 96 h 1 (x) = x mod 5, h 2 (x) = x mod Timo Bingmann, Christian Schulz

10 Universalität von Hashfunktionen 10 Timo Bingmann, Christian Schulz

11 Analyse für zufällige Hash-Funktionen Wiederholung Satz k : die erwartete Anzahl kollidierender Elemente ist O(1), falls M = O(m). M := {e M : key(e) k} für festes k definiere Kollisionslänge X := t[h(k)] die Anzahl der Element die auf den gleichen Slot gehasht werden 11 Timo Bingmann, Christian Schulz

12 Wahrscheinlichkeit für Kollision Wiederholung 0-1 ZV X e : 1 für h(e) = h(k), e M, 0 sonst 12 Timo Bingmann, Christian Schulz

13 Wahrscheinlichkeit für Kollision Wiederholung 0-1 ZV X e : 1 für h(e) = h(k), e M, 0 sonst E[X ] = E[ e M X e ] = e M E[X e ] = e M P [X e = 1] = M P [X e = 1] = = M Anzahl aller Hashfunktionen mit h(e)=h(k) {}}{ m Key 1 } m {{ Key } Anzahl aller Hashfunktionen = M 1 m = M m = O(1) = 12 Timo Bingmann, Christian Schulz

14 Wahrscheinlichkeit für Kollision Wiederholung 0-1 ZV X e : 1 für h(e) = h(k), e M, 0 sonst E[X ] = E[ e M X e ] = e M E[X e ] = e M P [X e = 1] = M P [X e = 1] = = M Anzahl aller Hashfunktionen mit h(e)=h(k) {}}{ m Key 1 } m {{ Key } Anzahl aller Hashfunktionen = M 1 m = M m = O(1) springender Punkt in Rechnung: Hashfunktion zufällig aus Menge aller möglichen ausgewählt nicht: Hashfunktion würfelt Wert für jeden Schlüssel. = 12 Timo Bingmann, Christian Schulz

15 Universelles Hashing Idee: nutze nur bestimmte einfache Hash-Funktionen H {0..m 1} Key ist universell falls für alle x, y in Key mit x y und zufälligem h H, P [h(x) = h(y)] = 1 m. Theorem gilt auch für universelle Familien von Hashfunktionen 13 Timo Bingmann, Christian Schulz

16 Universalität von Hashfunktionen Beispiele 14 Timo Bingmann, Christian Schulz

17 Bit-Matrix-Multiplikation Universalität h M (x) = Mx M {0, 1} w k, Arithmetik mod 2 (XOR and AND) Anzahl Slots m in Hashtabelle m = 2 w Beachte: x {0, 1} k und Mx {0, 1} w 15 Timo Bingmann, Christian Schulz

18 Bit-Matrix-Multiplikation Universalität h M (x) = Mx M {0, 1} w k, Arithmetik mod 2 (XOR and AND) Anzahl Slots m in Hashtabelle m = 2 w Beachte: x {0, 1} k und Mx {0, 1} w M = ( ) und x = (1, 0, 0, 1) T Mx mod 2 = (0, 1) T 15 Timo Bingmann, Christian Schulz

19 Bit-Matrix-Multiplikation Universalität h M (x) = Mx, M {0, 1} w k, m = 2 w Zu zeigen, für alle x y und h M gilt P[h M (x) = h M (y)] = 1 m für ein M gewählt aus allen möglichen. h(x) = h(y) Mx = My i {1,..., w} : k M ij x j = j=1 k M ij y j j=1 16 Timo Bingmann, Christian Schulz

20 Bit-Matrix-Multiplikation Universalität i {1,..., w} : k j=1 M ijx j = k j=1 M ijy j Anzahl Matrizen, die obiges Gleichungssystem lösen? w Gleichungen und wk Variablen M ij unterbestimmt, x y wk w Vektoren spannen Lösungsraum auf 2 wk w Lösungen 17 Timo Bingmann, Christian Schulz

21 Bit-Matrix-Multiplikation Universalität i {1,..., w} : k j=1 M ijx j = k j=1 M ijy j Anzahl Matrizen, die obiges Gleichungssystem lösen? w Gleichungen und wk Variablen M ij unterbestimmt, x y wk w Vektoren spannen Lösungsraum auf 2 wk w Lösungen Anzahl möglicher Matrizen M: 2 wk 17 Timo Bingmann, Christian Schulz

22 Bit-Matrix-Multiplikation Universalität i {1,..., w} : k j=1 M ijx j = k j=1 M ijy j Anzahl Matrizen, die obiges Gleichungssystem lösen? w Gleichungen und wk Variablen M ij unterbestimmt, x y wk w Vektoren spannen Lösungsraum auf 2 wk w Lösungen Anzahl möglicher Matrizen M: 2 wk P[h M (x) = h M (y)] = 2wk w 2 wk = 2 w = 1 2 w = 1 m 17 Timo Bingmann, Christian Schulz

23 Bloom Filter schnelle, ungenaue Suche 18 Timo Bingmann, Christian Schulz

24 Bloom Filters Randomisierte Datenstruktur Problem: INSERT und CONTAINS(e) Operationen CONTAINS(e): "ja", wenn e enthalten, "nein sonst erlaube false positive, d.h. Antwort ja, obwohl nicht enthalten Anwendungsbeispiele: Spellchecking Webcrawling 19 Timo Bingmann, Christian Schulz

25 Bloom Filters Randomisierte Datenstruktur Problem: INSERT und CONTAINS(e) Operationen CONTAINS(e): "ja", wenn e enthalten, "nein sonst erlaube false positive, d.h. Antwort ja, obwohl nicht enthalten Anwendungsbeispiele: Spellchecking Webcrawling Erste Idee: verwende Hashing (keine false positives) wir wollen weniger Speicher verwenden! 19 Timo Bingmann, Christian Schulz

26 Bloom Filters Randomisierte Datenstruktur n Elemente k 1 Hashfunktionen h i array A[0..., m 1] von Bits Insert(x): 1 setze A[h i (x)] = 1 i {1,..., k} Contains(x): 1 wenn A[h i (x)] = 1 i {1,..., k} ja 2 sonst nein 20 Timo Bingmann, Christian Schulz

27 Bloom Filters Insert Beispiel (k = 3) h 1 (x) h 2 (x) h 3 (x) contains(x) liefert JA! 21 Timo Bingmann, Christian Schulz

28 Bloom Filters Insert Beispiel (k = 3) h 1 (z) h 2 (z) h 3 (z) contains(z) liefert NEIN! 22 Timo Bingmann, Christian Schulz

29 Bloom Filters Insert Beispiel (k = 3) h 1 (y) h 2 (y) h 3 (y) contains(y x) liefert JA, obwohl y nicht einfügt wurde! 23 Timo Bingmann, Christian Schulz

30 Bloom Filters Wie wahrscheinlich sind false positives? ( e x = lim n 1 + x ) n n Annahme: Hashfunktionen haben uniform gleichverteiltes Bild p Wahrscheinlichkeit das Bit = 0 nach n Einfügungen p = ( ) 1 1 kn ( (1 ) m = 1 m ) kn/m m e kn/m Wahrscheinlichkeit für false positive also (1 p) k = (1 1 e kn/m ) k 24 Timo Bingmann, Christian Schulz

31 Bloom Filters Wie wahrscheinlich sind false positives? ( e x = lim n 1 + x ) n n Annahme: Hashfunktionen haben uniform gleichverteiltes Bild p Wahrscheinlichkeit das Bit = 0 nach n Einfügungen p = ( ) 1 1 kn ( (1 ) m = 1 m ) kn/m m e kn/m Wahrscheinlichkeit für false positive also (1 p) k = (1 1 e kn/m ) k optimialer Wert für k := m n ln 2 24 Timo Bingmann, Christian Schulz

32 Bloom Filters Rechenbeispiel Wahrscheinlichkeit für false positive (1 1 e kn/m ) k n = Objekte m = Bits wähle k = 7 Wahrscheinlichkeit für false positive < 1% Vorteile: viel kompaktere Repräsentation als Abspeichern von Objekten z.b. Strings, Webseiten, Hashwerte, Timo Bingmann, Christian Schulz

33 Bloom Filters Rechenbeispiel Wahrscheinlichkeit für false positive (1 1 e kn/m ) k n = Objekte m = Bits wähle k = 7 Wahrscheinlichkeit für false positive < 1% genauere Analyse: on the false-positive rate of bloom filters, Bose et. al Vorteile: viel kompaktere Repräsentation als Abspeichern von Objekten z.b. Strings, Webseiten, Hashwerte, Timo Bingmann, Christian Schulz

34 De-amortisierung 26 Timo Bingmann, Christian Schulz

35 Deamortisierung Unbounded Arrays Wichtige Operationen: access(n) in O(1) push_back(n) amortisiert in O(1) pop_back(n) amortisiert in O(1) Worst-Case: Ω(n) für push_back, pop_back 27 Timo Bingmann, Christian Schulz

36 Deamortisierung Unbounded Arrays Wichtige Operationen: access(n) in O(1) push_back(n) amortisiert in O(1) pop_back(n) amortisiert in O(1) Worst-Case: Ω(n) für push_back, pop_back Problem für Echtzeitsysteme!? 27 Timo Bingmann, Christian Schulz

37 Deamortisierung Unbounded Arrays Wichtige Operationen: access(n) in O(1) push_back(n) amortisiert in O(1) pop_back(n) amortisiert in O(1) Ziel: richtiges O(1) Idee: Bankkontomethode anpassen statt Einzahlung Arbeit verrichten Deamortisierung 27 Timo Bingmann, Christian Schulz

38 Deamortisierung Unbounded Arrays Arbeit statt Einzahlung: push_back starte direkt nach Verdoppelung Vorgehen: schreibe das eigentliche Element kopiere zwei weitere Elemente n + 1 2n 4n 28 Timo Bingmann, Christian Schulz

39 Deamortisierung Unbounded Arrays Arbeit statt Einzahlung: push_back starte direkt nach Verdoppelung Vorgehen: schreibe das eigentliche Element kopiere zwei weitere Elemente 28 Timo Bingmann, Christian Schulz

43 Deamortisierung Unbounded Arrays Arbeit statt Einzahlung: pop_back analog zu push_back Vorgehen: lösche das eigentliche Element kopiere ein weiteres Element 29 Timo Bingmann, Christian Schulz

44 Deamortisierung Unbounded Arrays Insgesamt: Worst-Case-Laufzeit auch in O(1) Nicht überall so leicht anwendbar. 30 Timo Bingmann, Christian Schulz

45 Sortieren Rebooted Die meisten intuitiven Sortieralgorithmen basieren auf: 1 Selection: finde das kleinste (oder größte) Element, und trenne es von den übrigen. Wiederhole bis alle ausgewählt wurden. 2 Insertion: betrachte Elemente einzeln und füge in sortierte Teilfolgen ein. 3 Exchange: vertauscht ungeordnete Paare von Elemente, bis keine weitere Vertauschungen notwendig sind. 4 Enumeration: vergleiche ein Element mit allen anderen. Dann platziere es endgültig an Hand der Anzahl kleiner Elemente. In der Regel erreichen diese nicht die untere Schranke Θ(n log n). 31 Timo Bingmann, Christian Schulz

46 Selection Sort Function selectionsort(a : Array of Element; n : N) for i := 0 to n 1 do min := i for j := i + 1 to n 1 do if A[j] < A[min] then min := j endfor swap(a[i], A[min]) invariant A[0] A[i] endfor // Suche kleinstes Element // Tausche Element an Anfang 32 Timo Bingmann, Christian Schulz

47 Selection Sort Function selectionsort(a : Array of Element; n : N) for i := 0 to n 1 do min := i for j := i + 1 to n 1 do if A[j] < A[min] then min := j endfor swap(a[i], A[min]) invariant A[0] A[i] endfor // Suche kleinstes Element // Tausche Element an Anfang Wieviele Vergleiche? 32 Timo Bingmann, Christian Schulz

48 Selection Sort Function selectionsort(a : Array of Element; n : N) for i := 0 to n 1 do min := i for j := i + 1 to n 1 do if A[j] < A[min] then min := j endfor swap(a[i], A[min]) invariant A[0] A[i] endfor // Suche kleinstes Element // Tausche Element an Anfang Wieviele Vergleiche? immer n(n 1) 2 = Θ ( n 2)! 32 Timo Bingmann, Christian Schulz

49 Insertion Sort Function insertionsort(a : Array of Element; n : N) for i := 1 to n 1 do j := i x := A[j] while (j > 0) & (A[j 1] < x) A[j] := A[j 1] j := j 1 endwhile A[j] := x invariant A[0] A[i] endfor // {A[0]} ist sortiert // Finde richtige Stelle j // Schiebe größere Elemente // nach hinten. // Setze Element 33 Timo Bingmann, Christian Schulz

50 Insertion Sort Function insertionsort(a : Array of Element; n : N) for i := 1 to n 1 do j := i x := A[j] while (j > 0) & (A[j 1] < x) A[j] := A[j 1] j := j 1 endwhile A[j] := x invariant A[0] A[i] endfor Vermeide j > 0 mit einem Sentinel A[ 1] :=. // {A[0]} ist sortiert // Finde richtige Stelle j // Schiebe größere Elemente // nach hinten. // Setze Element 33 Timo Bingmann, Christian Schulz

51 Insertion Sort Function insertionsort(a : Array of Element; n : N) for i := 1 to n 1 do j := i x := A[j] while (j > 0) & (A[j 1] < x) A[j] := A[j 1] j := j 1 endwhile A[j] := x invariant A[0] A[i] endfor // {A[0]} ist sortiert // Finde richtige Stelle j // Schiebe größere Elemente // nach hinten. // Setze Element Wieviele Vergleiche? worst-case? 33 Timo Bingmann, Christian Schulz

52 Insertion Sort Function insertionsort(a : Array of Element; n : N) for i := 1 to n 1 do j := i x := A[j] while (j > 0) & (A[j 1] < x) A[j] := A[j 1] j := j 1 endwhile A[j] := x invariant A[0] A[i] endfor // {A[0]} ist sortiert // Finde richtige Stelle j // Schiebe größere Elemente // nach hinten. // Setze Element Wieviele Vergleiche? worst-case: n (n 1) 2 = Θ ( n 2), average? 33 Timo Bingmann, Christian Schulz

53 Insertion Sort Function insertionsort(a : Array of Element; n : N) for i := 1 to n 1 do j := i // {A[0]} ist sortiert while (j > 0) & (A[j 1] < A[j]) // Finde richtige Stelle j swap(a[j 1], A[j]) // Schiebe größere Elemente j := j 1 // nach hinten. endwhile invariant A[0] A[i] endfor Wieviele Swaps? worst-case: n (n 1) 2 = Θ ( n 2), average? 33 Timo Bingmann, Christian Schulz

54 Insertion Sort Average Case Annahme: Alle Elemente verschieden und die Eingabe ist eine zufällige Permutation davon. Jede der n! Permutationen σ S n ist gleich wahrscheinlich. σ = ( ) 34 Timo Bingmann, Christian Schulz

55 Insertion Sort Average Case Annahme: Alle Elemente verschieden und die Eingabe ist eine zufällige Permutation davon. Jede der n! Permutationen σ S n ist gleich wahrscheinlich. Eine Paar (i, j) N 1 mit i < j ist eine Inversion, wenn σ(i) > σ(j). σ = ( ) Ein σ S n hat zwischen 0 und ( ) n Inversionen. 2 Beispiele: (1, 2, 3, 4, 5) und (5, 4, 3, 2, 1). 34 Timo Bingmann, Christian Schulz

56 Insertion Sort Average Case σ = ( ) Jeder Austausch falsch sortierter, benachbarter Positionen (swap) reduziert die Anzahl der Inversionen um genau 1. Die Anzahl von swaps in Insertion-Sort ist genau die Anzahl Inversionen in der Eingabe-Permutation. Nenne diese Anzahl X. Wir suchen den Erwartungswert: E(X ). 35 Timo Bingmann, Christian Schulz

57 Insertion Sort Average Case Wir zählen die erwartete Anzahl von Inversionen: Für eine Permutation σ S n sei { 1 falls (i, j) eine Inversion, X i,j := 0 sonst. Also ist X := i<j X i,j die Anzahl von Inversionen und ( ) E(X ) = E X i,j = E(X i,j ). i<j i<j Da E(X i,j ) = 1 2, ist so mit E(X ) = ( n 2 Worst case n (n 1) 2 = ) 1 2. ( ) n und average case 2 ( ) n Timo Bingmann, Christian Schulz

58 Merge Sort Function mergesort(a : Array of Element; lo, hi : N) if hi lo 1 then return // Basisfall mid := (lo + hi)/2 // mittleres Element mergesort(lo, mid), mergesort(mid, hi) // Sortiere Hälften T := allocate (Array of Element size hi lo) i := lo, j := mid, k := 0 // Laufindizes while i < mid & j < hi if A[i] < A[j] T [k++] := A[i++] // Mische! else T [k++] := A[j++] endwhile while i < mid do T [k++] := A[i++] // Kopiere Reste while j < hi do T [k++] := A[j++] A[lo,..., hi 1] := T [0,..., (hi lo) 1] // Kopiere zurück dispose (T ) Worst case: Θ(n log n), average case Θ(n log n). 37 Timo Bingmann, Christian Schulz

59 Sanders: Algorithmen I May 22, Quicksort erster Versuch Idee: Teile-und-Herrsche aber verglichen mit mergesort andersrum. Leiste Arbeit vor rekursivem Aufruf Function quicksort(s : Sequence of Element) : Sequence of Element if s 1 then return s pick some p s a:= e s : e p return concatenation of quicksort(a), b, and quicksort(c)

60 Sanders: Algorithmen I May 22, Quicksort: Effiziente Implementierung Array-Implementierung inplace 2-Wegevergleiche

61 Sanders: Algorithmen I May 22, Procedure qsort(a : Array of Element; l, r : N) if l r then return k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) qsort(a,l,m 1) qsort(a,m + 1,r)

62 Sanders: Algorithmen I May 22, Function partition(a : Array of Element; l, r, k : N) p:= a[k] swap(a[k],a[r]) i:= l l i j r invariant p > p? p for j := l to r 1 do if a[ j] p then swap(a[i],a[ j]) i++ l assert p i > p r p swap(a[i],a[r]) l assert p i p > p r return i // pivot

63 Sanders: Algorithmen I May 22, Beispiel: Partitionierung, k = 1 p, i, j

64 Sanders: Algorithmen I May 22, Beispiel: Rekursion

65 Sanders: Algorithmen I May 22, Größerer Basisfall Procedure qsort(a : Array of Element; l, r : N) if r l + 1 n 0 then insertionsort(a[l..r]) k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) qsort(a,l,m 1) qsort(a,m + 1,r)

66 Sanders: Algorithmen I May 22, ,6,8,1,0,7,2,4,5,9 Inplace? Wirklich? 0 3,6,8,1,7,2,4,5,9 Im schlechtesten Fall: O(n) für Rekursionsstapel. 1 3,6,8,7,2,4,5,9 2 3,6,8,7,4,5,9 3 6,8,7,4,5,9 4 6,8,7,5,9 Im Mittel: 5 6,8,7,9 O(log n) zusätzlicher Platz kein Problem. Als Garantie für schlechtesten Fall: 6 8,7,9 halbrekursive Implementierung Rekursion auf kleinere Hälfte 7 8,9 8 9

67 Sanders: Algorithmen I May 22, Halbrekursive Implementierung Procedure qsort(a : Array of Element; l, r : N) while r l + 1 > n 0 do k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) if m < (l + r)/2 then qsort(a,l,m 1); l:= m + 1 else qsort(a,m + 1,r); r:= m 1 insertionsort(a[l..r])

68 Sanders: Algorithmen I May 22, Halbrekursive Implementierung Procedure qsort(a : Array of Element; l, r : N) while r l + 1 > n 0 do k:= pickpivotpos(a, l, r) m:= partition(a, l, r, k) if m < (l + r)/2 then qsort(a,l,m 1); l:= m + 1 else qsort(a,m + 1,r); r:= m 1 insertionsort(a[l..r]) Satz: Rekursionstiefe log nn0 Beweisidee: Induktion. Teilproblemgröße halbiert sich (mindestens) mit jedem rekursiven Aufruf

69 Sanders: Algorithmen I May 22, Quadratische Komplexität bei gleichen Elementen? Variante aus dem Buch verwenden oder doch Drei-Wege-Partitionierung

70 Sanders: Algorithmen I May 22, Procedure qsortternary(a : Array of Element; l, r : N) if l r then return p:= key(a[pickpivotpos(a, l, r)]) (m,m ):= partitionternary(a,l,r, p) qsortternary(a, l, m 1) qsortternary(a,m + 1,r)

71 Sanders: Algorithmen I May 22, Function partitionternary(a : Array of Element; l, r : N; p : Key) i:= l, j:= l, k:= r l i j k r invariant p? = p while ( j k) if a[ j] = p then swap(a[ j], a[k]), k ; else if a[ j] p = p i := i + r k + 1 swap(a[i..i ],a[k + 1..r]) l assert p return (i,i )

72 Sanders: Algorithmen I May 22, Vergleich Quicksort Mergesort Pro Mergesort O(n log n) Zeit (deterministisch) qsort: det. Varianten nlogn + O(n) Elementvergleiche ( untere Schranke) qsort: möglich bei sorgfältiger Pivotwahl Stabil (gleiche Elemente behalten Reihenfolge bei) qsort: leicht bei Aufgabe der inplace-eigenschaft Pro Quicksort inplace Etwas schneller?

73 Vorgefertigte Sortieralgorithmen in aktuellen Programmiersprachen Verwenden Sie diese statt eigene zu implementieren! 38 Timo Bingmann, Christian Schulz

74 Java Zahlen: Variante von Quick-Sort int[] numbers = {42, 7, 9, 18, 1, 123}; java.util.arrays.sort(numbers) Allgemeine Elemente: Variante von Merge-Sort Comparator<Elem> comparator = new Comparator<Elem> { int compare(elem a, Elem b) { /*...*/ } } Elem[] elements = { /*...*/ } java.util.arrays.sort(elements, 3, 15, comparator) 39 Timo Bingmann, Christian Schulz

75 C++ Zahlen: #include <algorithm> int numbers[] = {42, 7, 9, 18, 1, 123}; std::vector<int> vec(numbers, numbers + 6); std::sort(vec.begin(), vec.end()) Allgemeine Elemente: #include <algorithm> bool less_than(elements& a, Elements& b) { /*...*/ }... Elements* elements = createelements(n); std::sort(elements, elements + n, less_than)...oder... std::stable_sort(elements, elements + n, less_than) 40 Timo Bingmann, Christian Schulz

76 time / (n log n) [ns] Sanders: Algorithmen I May 22, Benchmark Sortieren einer zufaelligen Sequenz (int) n InsertionSort MergeSort QuickSort JDK QuickSort

77 Sanders: Algorithmen I May 22, Auswahl (Selection) Definition: Rang der Elemente einer Folge s mit s = n: Abbildung r : 1..n 1..n mit i, j : s[i] < s[ j] r(i) < r( j). Grob: a[i] ist das r(i)-te Element von a. Frage: warum ist r nicht notwendig eindeutig? //return an element of s with rank k Function select(s : Sequence of Element; k : N) : Element assert s k

78 Sanders: Algorithmen I May 22, Auswahl Anwendungen Statistik Spezialfall Medianauswahl: k = s /2 allgemeinere Quantile (10 %,... ) Unterprogramm z. B. Eingabe eingrenzen auf vielversprechendste Elemente

79 Sanders: Algorithmen I May 22, Quickselect quicksort mit einseitiger Rekursion Function select(s : Sequence of Element; k : N) : Element assert s k pick p s uniformly at random a := e s : e p return select(c,k a b ) // a b c k k

80 Sanders: Algorithmen I May 22, Beispiel s k p a b c 3,1,4,5,9,2,6,5,3,5, ,4,5,9,6,5,3,5,8 3,4,5,9,6,5,3,5, ,4,5,5,3,5 6 9,8 3,4,5,5,3, ,4,3 5,5,5

81 Sanders: Algorithmen I May 22, Quickselect Analyse Function select(s : Sequence of Element; k : N) : Element assert s k pick p s uniformly at random a := e s : e p return select(c,k a b ) // a b c k Satz: quickselect hat erwartete Ausführungszeit O( s ) Beweis: hier nicht k

82 Sanders: Algorithmen I May 22, Mehr zum Auswahlproblem Tuning (array, inplace, 2-Wege-Vergleiche, iterativ) analog quicksort Deterministische Auswahl: quickselect mit spezieller det. Pivotwahl partielles Sortieren (z. B. einfache Variante von quickselect) weiss wie es geht? wer Weitere Verallgemeinerungen: mehrere Ränge, teilweise sortierte Eingaben,... Beispiel: Optimale Range Median Berechnung [B. Gfeller, P. Sanders, ICALP 2009]. Vorberechnungszeit O(n log n), Zeit O(log n) für a select( s[a],...,s[b],k) s k-th b