Übung Algorithmen I

Transkript

1 Übung Algorithmen I Christoph Striecks Christoph.Striecks@kit.edu (Mit Folien von Julian Arz, Timo Bingmann und Sebastian Schlag.)

2 Roadmap Wiederholung bzw. Zusammenfassung der Übung

3 Effizienz von Algorithmen

4 Effizienz von Algorithmen Algorithmen können sich in ihrer Effizienz stark unterscheiden (auch wenn sie als Software auf unterschiedlicher Hardware laufen) Beispiel: Sortieren von n Zahlen (aus [CLRS04]) Sortieren durch Einfügen c 1 n 2 Sortieren durch Mischen c 2 n log n Überlicherweise gilt c 1 < c 2

5 Effizienz von Algorithmen Setze n = 10 6, c 1 = 2 und c 2 = 50 Sortieren durch Einfügen Sortieren durch Mischen 2 (10 6 ) 2 Anw log 10 6 Anw. Rechner mit 2 GHz Rechner mit 500 MHz 2 (10 6 ) 2 Anw Anw. pro sec = 1000 sec log 10 6 Anw. = 0.6 sec Anw. pro sec Mit n = 10 7 : Sortieren durch Einfügen 27.8 h Sortieren durch Mischen 7 sec

6 Generelles Beispiel Laufzeit mit 10 9 Anw. pro Sekunde unter Eingabegröße n n 1000 log 2 n 500n 100n log 2 n 10n 2 n 3 2 n µs 5 µs 3.3 µs 1 µs 1 µs 1 µs µs 10 µs 8.6 µs 4 µs 8 µs 1.05 ms µs 25 µs 28.2 µs 25 µs 125 µs 13 h µs 50 µs 66.4 µs 100 µs 1 ms a µs 125 µs 199 µs 625 µs 15 ms µs 250 µs 448 µs 2.5 ms 125 ms µs 500 µs 1 ms 10 ms 1 s µs 5 ms 13.3 ms 1 s 16 min µs 50 ms 166 ms 100 s 11.6 d µs 500 ms 2 s 2.7 h 31.7 a µs 5 s 23 s 11.6 d a µs 50 s 4.4 min 3.2 a a

7 (Asymptotische) O-Notation O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 }

8 O-Notation (Intuition) O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 } f 1 (n)

9 O-Notation (Intuition) O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 } f 1 (n) c 1 n

10 O-Notation (Intuition) O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 } 150 c 2 n f 1 (n)

11 O-Notation (Intuition) O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 } 150 c 2 n f 1 (n) O(n) n

12 O-Notation (Intuition) O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 } 150 f 2 (n) / O(n) c 2 n f 1 (n) O(n) n

13 O-Notation (Intuition) O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 } 150 f 2 (n) Ω(n) f 1 (n) Ω (n) c 1 n n

14 (Asymptotische) Ω-Notation (Intuition) Ω(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 c g(n) f (n) für alle n n 0 }

15 Ω-Notation (Intuition) Ω(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 c g(n) f (n) für alle n n 0 } 150 f 2 (n) Ω(n) c 1 n n

16 Asymptotische Notationen O(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 f (n) c g(n) für alle n n 0 } Θ(g(n)) = {f (n) : es exist. pos. Konstanten c 1, c 2 und n 0, sodass 0 c 1 g(n) f (n) c 2 g(n) für alle n n 0 } Ω(g(n)) = {f (n) : es exist. pos. Konstanten c und n 0, sodass 0 c g(n) f (n) für alle n n 0 } Und weitere (siehe VL): o(g(n)), ω(g(n))

17 Nachtrag zum O-Kalkül Für nicht-negative f, g : N R gelten folgende Äquivalenzen: f (n) O(g(n)) 0 lim sup n f (n) Ω (g(n)) 0 < lim inf n f (n) g(n) = c <, f (n) g(n), f (n) f (n) o(g(n)) lim n g(n) = 0, f (n) ω(g(n)) lim sup n f (n) g(n) =, f (n) f (n) Θ(g(n)) = 0 < lim n g(n) = c <.

18 Korrektheit von Algorithmen

19 Invarianten Schleifeninvarianten (Folien von J. Arz, T. Bingmann, S. Schlag) nützliches Tool für Korrektheitsbeweise Schleifeninvariante muss 3 Bedingungen erfüllen: 1. Initialisierung: Invariante gilt vor erster Iteration 2. Fortsetzung: Invariante gilt vor Iteration i Invariante gilt vor Iteration i Terminierung: Abbruchbed. erfüllt Invariante gilt richtiges Ergebnis / Nachbedingung erfüllt

20 Invarianten Zusicherungen und Invarianten Vorbedingungen (Schleifen-)Invarianten Nachbedingungen Function power(a : R; n 0 : N) : R assert n 0 0 and (a = 0 n 0 = 0) p=a : R; r=1 : R; n=n 0 : N while n > 0 do invariant p n r = a n 0 if n is odd then n ; r:= r p else (n, p):= (n/2, p p) assert r = a n 0 return r

21 Invarianten Idee der Anwendung finde Schleifeninvariante zeige Schleifeninvariante Schleifeninvariante und sonstiges Wissen Korrektheit des Algorithmus Function max(a : Array [0..n 1] of R) : assert A.size() > 0 // Vorbedingung i=0 : N 0 j=1 : N 0 while j < n do if A[j] > A[i] then i := j ++j assert i = argmax l<n A[l] // Nachbedingung return i

22 Invarianten Beispiel I Function max(a : Array [0..n 1] of R) : assert A.size() > 0 // Vorbedingung i=0 : N 0 j=1 : N 0 while j < n do invariant i = argmax l<j A[l] // Invariante if A[j] > A[i] then i := j ++j assert i = argmax l<n A[l] // Nachbedingung return i nach Beenden der Schleife gilt: j = n und i = argmax l<j A[l] Nachbedingung gilt: i = argmax l<n A[l] Algorithmus liefert korrektes Ergebnis

23 Teile-und-Herrsche-Paradigma

24 Paradigma von Teile-und-Herrsche [CLRS04] Umfasst drei Schritte auf jeder Rekursionsebene: Teile das Problem in Teilproblemen. Beherrsche die Teilprobleme durch rekursives Lösen. Wenn die Teilprobleme hinreichend klein sind, dann löse diese direkt. Verbinde die Teillösungen zur Lösung des Ausgangsproblem.

25 Beispiel: Karatsuba-Ofman 1: Function recmult(a, b) 2: assert a und b haben n = 2k Ziffern, n ist Zweierpotenz 3: if n = 1 then return a b 4: Schreibe a als a 1 B k + a 0 5: Schreibe b als b 1 B k + b 0 6: c 11 := recmult(a 1, b 1 ) 7: c 00 := recmult(a 0, b 0 ) 8: c 1010 := recmult((a 1 + a 0 ), (b 1 + b 0 )) 9: e := c 11 B 2k + (c 1010 c 11 c 00 )B k + c 00 10: return e

26 Karatsuba-Ofman, Analyse Die Analyse von Karatsuba-Ofman ergibt eine Laufzeit von T (n) { 1 falls n = 1 3 T ( n/2 ) + 10n falls n > 1

27 Mastertheorem Einfache Form Für positive Konstanten a, b, c, d, sei n = b k für ein k N. { a falls n = 1 Basisfall T (n) = ( n ) cn + dt falls n > 1 teile und herrsche. b Es gilt Θ(n) falls d < b T (n) Θ(n log n) falls d = b Θ ( n log d) b falls d > b. Das Mastertheorem gibt uns für Karatsuba-Ofman: T (n) Θ ( n log 2 3)

28 Abschätzen von Rekurrenzen, Substitution

29 Abschätzen von Rekurrenzen Oft kann man Lösungen erraten. Falls nicht: obere Schranken zeigen! Beispiel: T (2n) = 2T (n) + 2n 1, T (2) = 1, n ist Zweierpotenz T (n) O(g(n))? (Für g(n) wie oben.)

30 Abschätzen von Rekurrenzen Erster Versuch: T (2n) = 2T (n) + 2n 1, T (2) = 1 Vermutung: T (n) = n 2? Müssen zeigen: T (2n) = (2n) 2 T (2n) = 2T (n) + 2n 1 2n 2 + 2n 1 < (2n) 2 (für n > 0) = T (n) < n 2.

31 Abschätzen von Rekurrenzen Zweiter Versuch: T (2n) = 2T (n) + 2n 1, T (2) = 1 Vermutung: T (n) = c n? Müssen zeigen: T (2n) = c (2n) T (2n) = 2T (n) + 2n 1 = 2cn + 2n 1 > 2cn (für n > 0) = T (n) > cn. Suche also Schranke zwischen cn und n 2

32 Abschätzen von Rekurrenzen Dritter Versuch: T (2n) = 2T (n) + 2n 1, T (2) = 1 Vermutung: T (n) = n log 2 n? Müssen zeigen: T (2n) = 2n log 2 2n T (2n) = 2T (n) + 2n 1 = 2n log 2 n + 2n 1 = 2n(log 2 n + log 2 2) 1 = 2n log 2 2n 1 < 2n log 2 2n = T (n) n log 2 n.

33 Variablenwechsel

34 Variablenwechsel T (n) = T ( n) + 1 für n = 2 2i, T (4) = 1

35 Variablenwechsel Wie löst man Rekurrenzen der Form T (n) = T ( n) + 1? Setze m = log n, also n = 2 m. Dann: T (2 m ) = T (2 m 2 ) + 1

36 Variablenwechsel T (2 m ) = T (2 m 2 ) + 1 Trick: setze S(m) := T (2 m ) liefert: ( m ) S(m) = S S(m) O(?)

37 Variablenwechsel T (2 m ) = T (2 m 2 ) + 1 Trick: setze S(m) := T (2 m ) liefert: ( m ) S(m) = S S(m) O(log m) Alternativ: nochmaliges Ausführen der Substitution (setze p = log 2 m, erhalte 2 p = m, S(2 p ) = S(2 p 1 ) + 1, weiter U(p) = S(m) = S(2 p ) = U(p 1) + 1 O(p) und einsetzen)

38 Variablenwechsel T (n) = T ( n) + 1 m = log n S(m) = S( m 2 ) + 1 S(m) O(log m) liefert für n = 2 2i : T (n) = T (2 m ) = S(m) O(log m) = O(log log n).

39 Amortisierte Analyse Beispiel Binärzähler β 2 β 1 β 0 i β i 2 i 2 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

40 Amortisierte Analyse Beispiel Binärzähler Binärzähler: zähle von 0 bis m m Inkrementoperationen x = i β i2 i Function binary-increment() : β 0 β i=0 : N 0 while β i = 2 do β i+1 β i β i 0 i i β 2 β 1 β 0 i β i 2 i 3 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

41 Amortisierte Analyse Beispiel Binärzähler Kostenmodell: Kosten 1 pro Bitflip T (m) seien Gesamtkosten für m Operationen amortisierten Kosten pro Operation definiert als T (m)/m amortisierten Kosten einer Inkrementoperation? a) O(1) b) O(log m) 5 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

42 Beispiel Binärzähler Aggregatmethode Kochrezept: Schätze T (m) direkt ab Operation Kosten Beobachtung (m Ops): β 0 jedes mal gekippt β 1 jedes zweite mal gekippt β 2 jedes vierte mal gekippt β 3 jedes achte mal gekippt... T (m) m + m 2 + m 4 + m 8... i=0 m 2 i = 2m = m = m 2 = m 4 = m Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

43 Beispiel Binärzähler Aggregatmethode Kochrezept: Schätze T (m) direkt ab Operation Kosten Beobachtung (m Ops): β 0 jedes mal gekippt β 1 jedes zweite mal gekippt β 2 jedes vierte mal gekippt β 3 jedes achte mal gekippt... T (m) m + m 2 + m 4 + m 8... i=0 m 2 i = 2m T (m) m 2 = O(1) = m = m 2 = m 4 = m Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

44 Beispiel Binärzähler Bankkontomethode Allgemein: t 1,..., t m die Laufzeiten der Einzeloperationen t i Gebühr für i-te Operation vor jeder Operation erhält Algorithmus Gehalt G alle Operationen müssen aus Gehältern bezahlt werden finde Gehalt G, sodass T (m) mg 7 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

45 Beispiel Binärzähler Bankkontomethode finde Gehalt G, sodass mit T (m) mg Binärzähler: G = 2 Chips, Strategie: Zählvorgang setzt genau ein Bit auf 1. Dies kostet 1 Chip 8 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

46 Beispiel Binärzähler Bankkontomethode finde Gehalt G, sodass mit T (m) mg Binärzähler: G = 2 Chips, Strategie: Zählvorgang setzt genau ein Bit auf 1. Dies kostet 1 Chip Spare anderen Chip, um Bit auf 0 zu setzen 8 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

47 Beispiel Binärzähler Bankkontomethode finde Gehalt G, sodass mit T (m) mg Binärzähler: G = 2 Chips, Strategie: Zählvorgang setzt genau ein Bit auf 1. Dies kostet 1 Chip Spare anderen Chip, um Bit auf 0 zu setzen Invariante: Kontostand = Anzahl der 1-Bits 8 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

48 Beispiel Binärzähler Einzelkosten 5 4 T(m)-T(m-1) Operationen 9 2. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

49 Beispiel Binärzähler Summierte Kosten T(m) Operationen Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

50 Beispiel Binärzähler Summierte Kosten 2m T(m) Operationen Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

51 Beispiel Binärzähler T (m)/m T(m)/m Operationen Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

52 Unbounded Array Wieviele Speicherzellen braucht ein Unbounded Array gleichzeitig für n Elemente? Worst-Case-Betrachtung es darf eine beliebige Folge von pushback und popback Operationen vorausgegangen sein a) 2n ± c b) 3n ± c c) 4n ± c d) 6n ± c Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

53 Unbounded Array live! Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

61 Unbounded Array live! Platzbedarf bei Vergrößerung: 3(n 1) Speicherzellen falls maximales n bekannt: bounded array oft besser Antwort b richtig? Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

62 Unbounded Array live! Warum schrumpft das Array nicht? die Zukunft nicht bekannt (Stichwort Online-Algorithmus) Problem: erneutes pushback erneutes O(n) Anwachsen Problem: Folge von n solcher popback / pushback O ( n 2) Laufzeit Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

63 Unbounded Array live! Warum schrumpft das Array nicht? die Zukunft nicht bekannt (Stichwort Online-Algorithmus) Problem: erneutes pushback erneutes O(n) Anwachsen Problem: Folge von n solcher popback / pushback O ( n 2) Laufzeit deshalb erst bei 1/4 schrumpfen Ω (n) konstante Operationen seit dem letzten Anwachsen/Schrumpfen Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

67 Unbounded Array live! Platzbedarf direkt vor Schrumpfoperation: 4(n 1) Speicherzellen Antwort c richtig? Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

68 Unbounded Array live! Wenn Feldkapazität 4n schrumpfe Feld auf 2n es bleibt Platz für weitere Elemente während Schrumpfoperation: 6n Speicherzellen gleichzeitig belegt außer Speicherverwaltung bietet Schrumpfoperation ohne Kopieren Antwort d richtig! Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

69 Unbounded Array: Allgemeine Version Kompromiss: im schlimmsten Fall weniger Platz, dafür langsamer? Ja! Durch Wahl des: " Vergrößerungsfaktors" β (hier bisher immer 2) " Schranke" α (hier bisher immer 4) der verallgemeinerten Version: realloziere βn verkleinere bei αn w n > 0 amortisierte Laufzeiten bleiben asymptotisch gleich für β > 1, α > β. größeres β, α: schneller, benötigt aber mehr Speicherplatz kleineres β, α: langsamer, benötigt aber weniger Speicherplatz Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

70 Hashtabellen: Beispielanwendung: Duplikaterkennung 2 3. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

71 Duplikaterkennung Problem: Gegeben: Folge A := a 1, a 2,..., a n von Zahlen Frage: Enthält A ein oder mehrere Duplikate a i = a j, i j? Ansatz 1: Löse Problem mit Sortieren Idee: Sortiere A A := a 1,..., a n. In A stehen Duplikate nebeneinander A von links nach rechts durchlesen liefert alle Duplikate Worst-Case Laufzeit: Ω(n log n) (siehe Vorlesung Sortieren & Co ) 3 3. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

72 Duplikaterkennung Problem: Gegeben: Folge A := a 1, a 2,..., a n von Zahlen Frage: Enthält A ein oder mehrere Duplikate a i = a j, i j? Ansatz 2: Verwende eine Hashtabelle H (mit verketteten Listen) Idee: Füge a 1,..., a n nacheinander in H ein Zahl schon drin: Duplikat erkannt! Laufzeit: Erwartet O(n) Bei zufälliger Hashfunktion und wenn H mindestens Ω(n) Slots hat 3 3. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

73 Erkennen von Duplikaten mittels Hashtabelle Laufzeitanalyse Zwei Schritte 1 Erzeugen der Hashtabelle 2 Finden und Einfügen aller a i aus A = a 1,..., a n 6 3. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

74 Erkennen von Duplikaten mittels Hashtabelle Laufzeitanalyse Zwei Schritte 1 Erzeugen der Hashtabelle Alle Slots mit Null-Zeiger initialisieren Zeit: O( A ), da Tabelle A Slots hat 2 Finden und Einfügen aller a i aus A = a 1,..., a n 6 3. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

75 Erkennen von Duplikaten mittels Hashtabelle Laufzeitanalyse Zwei Schritte 1 Erzeugen der Hashtabelle Alle Slots mit Null-Zeiger initialisieren Zeit: O( A ), da Tabelle A Slots hat 2 Finden und Einfügen aller a i aus A = a 1,..., a n Zeit pro Einfügen: O(1) Zeit pro H.find(a): O(Listenlänge) Aber: Erwartete Laufzeit O(1) Denn: Tabelle hat A Slots Hierzu Satz aus Vorlesung: erwartete Listenlänge O(1) Gesamtzeit für Finden und Einfügen: erwartet O( A ) 6 3. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

76 Unbounded Hashtables Amortisierung Problem Anzahl der einzufügenden Elemente nicht bekannt Was passiert wenn eine Hashtabelle zu voll wird? Hashing mit linearer Suche: Überlauf Hashing mit verk. Liste: Verlangsamerung der Operationen Lösung: Hashtabelle dynamisch vergrößern und verkleinern Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

77 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 Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

78 Unbounded Hashtables mit verketteten Listen Problem: Hashfunktion 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 alle neu einfügen Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

79 Unbounded Hashtable 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 Bankkontomethode Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

80 Neue Hashfunktion wählen Beispiel Hashen von Zahlen h(x) = x mod Tabellengröße Problem: Tabellengröße = 2 k Entspricht Extrahieren der k niedrigsten Bits Nur k niedrigsten Bits nehmen Einfluss Besser: Tabellengröße immer Primzahl Möglichst weit entfernt von Zweierpotenzen Implementierung: Primzahlentabelle Wähle bei Größenänderungen die nächstgrößere Primzahl aus Tabelle Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

81 Rehash Beispiel insert: 22, 42, 9, 25, 18 und 96 h 1 (x) = x mod 5, h 2 (x) = x mod Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

82 Wiederholung: Wahrscheinlichkeitstheorie Elementarereignisse: Ω Ereignisse: Teilmengen von Ω Gleichverteilung: p y = 1 Ω Zufallsvariable: X : Ω R 0-1-Zufallsvariable: I : Ω {0, 1} Erwartungswert: E[X ] = y Ω p y X (y) Linearität des Erwartungswerts: E[X + Y ] = E[X ] + E[Y ]

83 Sortieren durch Auswählen (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 // Suche kleinstes Element if A[j] < A[min] then min := j endfor swap(a[i], A[min]) // Tausche Element an Anfang invariant A[0] A[i] endfor Wie viele Vergleiche? (Demo-Beispiel) immer n(n 1) 2 Θ ( n 2)

84 Sortieren durch Einfügen (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) // Finde richtige Stelle j A[j] := A[j 1] // Schiebe größere Elemente j := j 1 // nach hinten. endwhile A[j] := x // Setze Element invariant A[0] A[i] endfor Trick: vermeide j > 0 mit einem Sentinel A[ 1] :=. Wie viele n (n 1) Vergleiche? (Demo-Beispiel) worst-case: = Θ ( n 2), 2 average?

85 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 in σ, X i,j (σ) := 0 sonst. Also ist X (σ) := i<j X i,j (σ) die Anzahl von Inversionen und ( ) E(X (σ)) = E X i,j (σ) = i<j 1 i<j n E(X i,j (σ)). Da E(X i,j (σ)) = 1 ( ) n 2, gilt E(X (σ)) = ( ) ( ) n (n 1) n n Worst case = und average case

86 Sortieren durch Mischen Idee: Teile und Herrsche Function mergesort( e 1,...,e n ) : Sequence of Element if n = 1 then return e 1 // base case else return merge( mergesort( e 1,...,e n/2 ), mergesort( e n/2 +1,...,e n )) Gegeben: zwei sortierte Folgen a und b Berechne: sortierte Folge der Elemente aus a und b 172

87 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).

88 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 b:= e s : e = p c:= e s : e > p return concatenation of quicksort(a), b, and quicksort(c) 182

89 Quicksort Analyse im schlechtesten Fall Annahme: Pivot ist immer Minimum (oder Max.) der Eingabe { Θ(1) if n = 1, T (n) = Θ(n) + T (n 1) if n 2. T (n) = Θ(n + (n 1) + + 1) = Θ ( n 2) 183

90 Schlechtester Fall: Beispiel 184

91 Quicksort Analyse im besten Fall Annahme: Pivot ist immer Median der Eingabe { O(1) if n = 1, T (n) O(n) + 2T ( n/2 ) if n 2. (Master-Theorem) T (n) = O(n log n) Problem: Median bestimmen ist nicht so einfach 185

92 Einige Quicksort-Analysen Hoare (1962) Ur -Quicksort Average Case für 1 zufällig gewähltes Pivot für n = 100 erwartete Vergleiche: = 2n(H n 1) 837, 5 2n log e n 921, 0 Wild, Nebel (2012) Yaroslavskiy -Quicksort Average Case für 2 zufällig gewählte Pivots erwartete Vergleiche: für n = 100 = 1.9n log e n 2.46n + O(log n) O(log 100) (Demo.)

93 Kennzahlen der Vorsortiertheit und adaptive Sortierverfahren

94 Adaptives Sortieren Kennzahlen der Vorsortiertheit Inversionen Runs Größte Distanz zwischen Inversionen Größte Distanz zur korrekten Position Vertauschungen Verschachtelte Listen Removals SUS SMS Oszillationen Alle anderen zusammen

95 Adaptives Sortieren Kennzahlen der Vorsortiertheit Inversionen Nachteil: Lokale Sortiertheit wird nicht erkannt. Beispiel: Quadratische Anzahl von Inversionen, aber einfach zu sortieren Runs Ein Run ist eine zusammenhängende Teilfolge aufsteigend sortierter Elemente Das obige Beispiel hat 2 Runs. Best case m runs = 1, worst case m runs = n Average case?

96 Adaptives Sortieren Kennzahlen der Vorsortiertheit Runs Nachteil: Globale Sortiertheit wird nicht erkannt Beispiel: Viele Runs, aber nur zwei ineinander verschränkte aufsteigende Teilsequenzen Removals Removals: minimale Anzahl von Elementen, deren Löschen eine sortierte Folge erzeugt Das Beispiel hat eine längste aufsteigende Teilsequenz der Länge 5 m rem = 4 Best case: m rem = 0; worst case: m rem = n 1

97 Perfekte Binärbäume

98 Perfekter Binärbaum Beispiel: n = 15 Knoten b = 8 Blätter c = 7 innere Knoten h = 3 Höhe Definition: Die Höhe h eines Baums ist die maximale Pfadlänge von der Wurzel zu einem Blatt. n = h 2 i = 2 h+1 1 i=0 h = log 2 n

99 Perfekter Binärbaum Beispiel: n = 15 Knoten b = 8 Blätter c = 7 innere Knoten h = 3 Höhe (Level-order-Traversierung.)

100 Perfekter Binärbaum Beispiel: n = 15 Knoten b = 8 Blätter c = 7 innere Knoten h = 3 Höhe i 2i + 1 (Level-order-Traversierung.)

101 Traversierungen von Binärbäumen Beispiel: n = 15 Knoten b = 8 Blätter c = 7 innere Knoten h = 3 Höhe (Pre-order-Traversierung.)

102 Traversierungen von Binärbäumen Beispiel: n = 15 Knoten b = 8 Blätter c = 7 innere Knoten h = 3 Höhe (In-order-Traversierung.)

103 Traversierungen von Binärbäumen Beispiel: n = 15 Knoten b = 8 Blätter c = 7 innere Knoten h = 3 Höhe (Post-order-Traversierung.)

104 (Max-)Heap und Suchbaum Max-Heap 9 Suchbaum Invariante: Für alle Knoten v gilt parent(v) v. Invariante: Für alle Knoten v gilt w left(v) : w v und w right(v) : w > v.

105 (Max-)Heap und Suchbaum Max-Heap Invariante: Für alle Knoten v gilt parent(v) v. Priority-Queue-Operationen: insert(v) deletemax(v) Heap-Operationen: siftup(v) siftdown(v) buildheap(h[1..n])

106 Heapsort mit Max-Heap

107 Heapsort Procedure selectionsort(a : Array of R) 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 swap(a[i], A[min]) Laufzeit: n Iterationen, pro Iteration O(n) O ( n 2) Operationen: sucheminimum in O(n), entferneminimum in O(1) Wem kommen diese Operationen bekannt vor? deletemin der Priority Queue, Zeit: O(log n) Heap als bessere Datenstruktur für Selectionsort O ( n 2) vs. O(n log n)

108 Adressierbare binäre Heaps

109 Adressierbare binäre Heaps Idee: Proxy-Array p speichert Handles auf Elemente im Heap H Ermöglicht Operationen H.decreaseKey(p[i], k) (Schlüssel veringern) H.remove(p[i], k) (Element enfernen) Problem: Heap ist in Bewegung Handles müssen beim Tauschen auch vertauscht werden Elemente im Heap brauchen Rückpointer auf Einträge im Proxy-Array

110 Adressierbare binäre Heaps h p Procedure decreasekey(h : Handle, k : Key) assert k key(h) key(h):= k siftup(h) Achtung: invariant proxy(p[i]) = i

111 Die Anzahl binärer Suchbäume

112 Binäre Suchbäume Wiederholung In der Vorlesung: Daten nur an Blättern Hier in der Übung: Daten in allen Knoten Invariante: Für alle Knoten v: w left(v) : w v und w right(v) : w > v

113 Die Anzahl binärer Suchbäume C n x < x > x Bekannte Startwerte: C 0 = 0, C 1 = 1, C 2 = 2, C 3 = 5, C 4 = 14. Durch Partitionieren der sortieren Folge: C n = C 0 C n 1 + C 1 C n C n 2 C 1 + C n 1 C 0, n > 0. Wende erzeugende Funktionen an: C(z) = n=0 C n heißen die Catalan-Zahlen. C z z n = C(z) zc(z) + 1. = C n = 1 ( ) 2n. n + 1 n

114 Balancierte binäre Suchbäume: Rot-Schwarz-Bäume

115 Binäre Suchbäume Wiederholung Invariante: Für alle Knoten v: w left(v) : w v und w right(v) : w > v Problem von binären Suchbäumen: können unbalanciert sein Lösung der Vorlesung: (a, b)-bäume Weitere Lösung hier in der Übung: Rot-Schwarz-Bäume

116 Warum balancierte Bäume? 1 2 Höhe: h O(n) Suchen: O(n) im Worst Case Löschen: O(n) im Worst Case 3 Einfügen: O(n) im Worst Case 4 5 Geht das besser? Ja, Rot-Schwarz-Bäume garantieren Höhe von O(log n).

117 Rot-Schwarz-Bäume Rot-Schwarz-Bäume sind binäre Suchbäume mit folgenden Eigenschaften: Jeder Knoten ist entweder rot oder schwarz. (1 Bit mehr an Information pro Knoten.) Die Wurzel ist schwarz. Jedes Blatt ist schwarz und enthält keine Werte. (Nur innere Knoten enthalten Werte.) Ist ein Knoten rot, so sind beide Kinder schwarz. Für alle Knoten v: Alle Pfade von v zu einem Blatt enthalten die gleiche Anzahl schwarzer Knoten

118 Was ist eine Rotation? Lokale Operation, die die binäre Suchbaumeigenschaft erhält Umhängen einer konstanten Zahl an Pointern pro Teilbaum a Linksrotation b b Rechtsrotation a a > b (a, b] > b a (a, b]

119 Rot-Schwarz-Bäume Aufwandsabschätzung Speicher: 1 Bit pro Knoten für die Farbe Parent-Pointer ist nötig Zeit: Konstanter Aufwand pro Knoten (Färben und Rotieren) Maximal O(log n) Rekursionstiefe Ziel erreicht: O(n) Platz und alle Operationen in O(log n).

120 Grundlagen der Graphentheorie 2 8. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

121 Graphen und Relationen Relation Ist eine Menge M gegeben, dann heißt R M M eine Relation und man schreibt auch x R y, falls (x, y) R. Spezielle Relationen: symmetrisch, transitiv, antisymmetrisch, Äquivalenz-Relationen, etc. Beispiele: x = y, x y oder x y (teilt). gerichteter Graph Ein gerichteter Graph G = (V, E) besteht aus Knoten V und Kanten E, wobei V nicht leer ist und E V V ist. ungerichteter Graph Ein ungerichteter Graph G = (V, E) besteht aus Knoten V und Kanten E, wobei V nicht leer ist und E {{x, y} x, y V } ist Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

122 Adjazenz und Knotengrad Sei G = (V, E) ein ungerichteter Graph. Bereits bekannt: Ein Knoten x V und eine Kante e E heißen inzident, wenn x e. Zwei Knoten x, y V mit x y heißen adjazent, wenn es eine Kante e E mit x e und y e gibt. Für ein Knoten x V ist die Adjazenzmenge oder Nachbarn-Menge also Adj(x) = {y V x y und {x, y} E}. Der Grad eines Knoten x V ist deg(x) := Adj(x). (auch deg G (x) oder d G (x) oder γ G (x) oder...) 6 8. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

123 Knoten mit speziellem Knotengrad Ein Knoten v V mit deg(v) = 0 heißt isoliert. Ein Knoten v V mit deg(v) = 1 heißt Randknoten. Ein Graph G = (V, E) heißt knotenregulär vom Grad r, wenn deg(v) = r für alle v V gilt. Beispiel: der Hyperwürfel Q 3 ist 3-knotenregulär. Ein ( V 1)-knotenregulärer Graph heißt vollständig. K 6 K 4 K Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

124 Handshake-Lemma Lemma: Ist G = (V, E) ein ungerichteter Graph, dann gilt deg(v) = 2 E. v V 8 8. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

125 Adjazenz- und Inzidenzmatrix v 1 e 1 e 2 e 3 v 2 v 3 e 4 e 5 e 6 e 7 v 4 v A = H = Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

126 Adjazenzfelder V E Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

127 Graphen als Matrizen Symmetrie Ungerichteter Graph symmetrische Adjazenzmatrix A = A T Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

128 Unter- oder Teilgraphen Definition: Ein Graph G = (V, E ) ist ein Untergraph oder Teilgraph von G = (V, E), geschrieben G G, wenn V V, E E und für alle {v 1, v 2 } E sowohl v 1 V als auch v 2 V. Definition: Ist G = (V, E) ein Graph und V V eine Knotenmenge, dann heißt der Graph G[V ] := (V, E ) mit E = {{v 1, v 2 } E v 1, v 2 V } der durch V knoten-induzierte Teilgraph von G. Definition: Ist G = (V, E) ein Graph und E E eine Kantenmenge, dann heißt der Graph G[E ] := (V, E ) mit V = {v 1, v 2 } der durch E kanten-induzierte Teilgraph von G. {v 1,v 2 } E Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

129 Wege, Kreise und Zusammenhang Ist G = (V, E) ein ungerichteter Graph, dann heißt eine Folge (v 0, e 1, v 1, e 2,..., v n 1, e n, v n ) mit v i V und e i E eine Kantenfolge, ein Kantenweg oder nur Weg (path), wenn e i = {v i 1, v i } für i = 1,..., n. Alternativ, kann man in Graphen ohne Mehrfachkanten eine Kantenfolge auch durch die Knotenspur (v 0,..., v n ) beschreiben. heißt eine Kantenfolge ein Kantenpfad oder nur Pfad (simple path), wenn alle besuchten Knoten verschieden sind. heißen zwei Knoten x, y V verbindbar (connected), wenn es einen Weg mit x = v 0 und y = v n gibt. heißt der Graph G zusammenhängend (connected), wenn jedes Paar (x, y) V V verbindbar ist Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

130 Wege, Kreise und Zusammenhang Ist G = (V, E) ein ungerichteter Graph, dann heißt ein Kantenfolge (v 0, e 1, v 1, e 2,..., v n 1, e n, v n ) ein Kantenkreis oder Kantenzyklus (cycle), wenn v 0 = v n, ein Kantenkreis einfach (simple), wenn alle besuchten Knoten außer v 0 und v n verschieden sind, und der Graph G kreisfrei, kreislos oder zykelfrei (cycle free), wenn G keinen Kantenkreis enthält Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

131 Eulersche und Hamiltonsche Kreise Ein Kantenkreis heißt Eulersch, wenn er alle Kanten des Graphen genau einmal enthält. Ein Kantenkreis heißt Hamiltonsch, wenn er alle Knoten des Graphen genau einmal enthält (Beginn und Ende einmal gezählt). Ein Graph heißt Eulersch/Hamiltonsch, wenn er einen Eulerschen/Hamiltonschen Kreis enthält Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

132 Satz von Euler (Graphen) Satz: Ein Graph G = (V, E) mit E ist genau dann Eulersch, wenn G zusammenhängend ist und alle Knoten geraden Knotengrad haben Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

133 Breiten- und Tiefensuche in Graphen 3 9. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

134 Wiederholung: Breitensuche Procedure bfs(g=(v, E) : Graph, s: node) Q=[ ] : Queue Q.enqueue(s) label s as visited while Q is not empty do v = Q.dequeue() process(v) foreach w : {v, w} E do if w not visited then Q.enqueue(w) label w as visited 4 9. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

135 Wiederholung: Tiefensuche rekursiv Procedure dfs(g=(v, E) : Graph, v: node) label v as visited process(v) foreach w : {v, w} E do if w not visited then dfs(g,w) 5 9. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

136 Tiefensuche iterativ Procedure dfs(g=(v, E) : Graph, s: node) S=[ ] : Stack S.push(s) label s as visited while S is not empty do v = S.pop() if v is not visited then label v as visited process(v) foreach w : {v, w} E do S.push(w) 6 9. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

137 DFS iterativ oder rekursiv: Was ist besser? Performancefrage nicht pauschal zu beantworten - hängt von komplizierten Einflüssen ab, z.b. Compileroptimierungen Cache-Effekten Tiefe der Suche... Also: Profiling und Experimente mit echtem Code ( algorithm engineering) 7 9. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

138 Beispielanwendung Breitensuche Problem: Ist ein (zusammenhängender) Graph bipartit? Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

139 Beispielanwendung Breitensuche Lösung in O(m): Knoten schwarz oder rot einfärben während der Breitensuche. 11 Procedure isbipartite(g=(v, E) : Graph, s: node) Q=[ ] : Queue set color to red Q.enqueue(s); label s as visited color s while Q is not empty do v = Q.dequeue() switch color foreach w : {v, w} E do if w not visited then Q.enqueue(w); label w as visited color w else if w has same color as v return false return true 9. Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

140 Breitensuche.. für nicht zusammenhängende, gerichtete Graphen Function dobfs(g = (V, E)) isroot=true : Array of {0, 1} foreach (u, v) E do b[v] := False Q = v V, b[v] = True : 6 3 Finde zunächst alle Wurzeln (jeder DAG hat mind. eine!) Oder: Setze erstes Level := Menge d. Wurzeln Eine imaginäre Wurzel zu allen echten Wurzeln Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

141 Bäume Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

142 Charakterisierung von Bäumen Definition: Ein ungerichteter Graph heißt Baum, wenn es von jedem Knoten zu jedem anderen Knoten genau einen Kantenweg gibt. Satz: Für einen ungerichteten Graphen G = (V, E) sind äquivalent: 1 G ist ein Baum. 2 G ist zusammenhängend und E = V 1. 3 G ist zusammenhängend und kreislos. 4 G ist kreislos und E = V 1. 5 G ist maximal kreislos: G ist kreislos und jede zusätzliche Kante zwischen nicht-adjazenten Knoten ergibt einen Kreis. 6 G ist minimal zusammenhängend: G ist zusammenhängend und bei Entfernen einer beliebige Kante zerfällt G Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

143 Satz von Cayley Ist G = (V, E) ein zusammenhängender ungerichteter Graph, dann heißt ein Untergraph (V, E ) mit E E ein G aufspannender Baum, wenn dieser ein Baum ist. Satz von Cayley Im vollständigen Graph K n gibt es genau n n 2 verschiedene K n aufspannende Bäume. Beispiel: K 4 hat folgende 16 aufspannende Bäume: Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

144 Kürzeste Wege in Graphen Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

145 Bellman-Ford-Algorithmus Wiederholung Ausgehend von einem Knoten s berechne kürzesten Wege-Baum 1: procedure BellmanFord(s : NodeId) : NodeArray NodeArray 2: d =,..., : NodeArray of R {, } 3: parent =,..., : NodeArray of NodeId 4: d[s] := 0; parent[s] := s 5: for i := 1 to n 1 do 6: forall e E do relax(e) 7: 8: forall e = (u, v) E do 9: if d[u] + c(e) < d[v] then Error: "Graph contains negative cycle" 10: return (d, parent) Erinnerung Kante (u, v) relaxieren: 1 wenn d[u] + c(u, v) < d[v] dann d[v] := d[u] + c(u, v), parent[v] := u Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

146 Bellman-Ford vs Dijkstra Dijkstra: greedy wählt Knoten mit minimaler Distanz und relaxiert ausgehende Kanten Bellman-Ford: nicht greedy relaxiert alle Kanten n 1 mal Bellman-Ford funktioniert mit negativen Kantengewichten Bellman-Ford funktioniert nicht, falls G negativen Kreis enthält aber detektiert solche Kreise und bricht ab Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

147 Durchmesser ungerichteter Graphen Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

148 Durchmesser ungerichteter Graphen Intuitiv: Größter Abstand zweier Knoten im Graph. Frage: Was ist der Abstand zweier Knoten im Graph? Antwort: Länge des kürzesten Pfades zwischen zwei Knoten. Frage: Was ist die Länge eines Pfades? Antwort: Die Anzahl Kanten des Pfades. H B G A D E F Kürzester Weg von I nach H, Länge = 4 Abstand von I und H = 4 Größter Abstand Durchmesser = 4 C I Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

149 Durchmesser ungerichteter Graphen Mathematische Definition mit ( ) Durchmesser := max min P u,v V P P(u,v) P(u, v) ist Menge aller Pfade zwischen u und v P ist Anzahl der Kanten eines Pfades P Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

150 Durchmesser ungerichteter Graphen Algorithmus Idee: 1: D = 0 : N 0 2: for each u V do 3: Berechne kürzeste Pfade von u zu allen v V \{u} 4: D := max{d, größte gefundene Pfadlänge} 5: return D Laufzeit: O(n Laufzeit Zeile 3) Übung Algorithmen I Fakultät für Informatik Institut für Theoretische Informatik

151 Übungsblätter Übungsblatt 1: Zahlenfolge, kein Überlauf in Multiplikation, Karatsuba-Ofman-Multiplikation Übungsblatt 2: O-Kalkül, Anwendung Mastertheorem, asymptotisches Sortieren, Pseudocode-Algorithmus (Doktor Meta) Übungsblatt 3: Rekursionsgleichungen, einfach verkettete Listen, amortisierte Analyse

152 Übungsblätter Übungsblatt 4: Hashing, Plagiatsdetektor, Wahrscheinlichkeitstheorie Übungsblatt 5: Kombinatorik, Sortieren, Sortieralgorithmen sortieren, In-place-Duplikaterkennung Übungsblatt 6: Algorithmendesign, paralleles Sortieren, Prioritätslisten-Datenstruktur (Doktor Meta)

153 Übungsblätter Übungsblatt 7: Binäre Heaps, Radixsort, k-core-zerlegung Übungsblatt 8: Heapsort mit Max-Heap, (a,b)-bäume, modellieren mit Graphen Übungsblatt 9: Dijkstras Algorithmus, Pseudocode (Doktor Meta), Breitensuche

154 Übungsblätter Übungsblatt 10: Tiefensuche iterativ, bipartite Graphen, kürzeste Pfade Übungsblatt 11: Bellman-Ford-Algorithmus, Jarník-Prims und Kruskals Algorithmus, Minimum Spanning Tree (MST) Übungsblatt 12: Programmieraufgabe: Kruskals Algorithmus und Union-Find-Datenstruktur, Neues Rucksackproblem

155 Zu guter Letzt... Viel Erfolg bei der Klausur!