Transkript

1 Wie beim letzten Mal - bitte besucht: Ihr seid gleich wieder gefragt...

2 Übung Algorithmen I Lukas Barth lukas.barth@kit.edu (Mit Folien von Julian Arz, Timo Bingmann, Sebastian Schlag und Christoph Striecks)

3 Organisatorisches Zweimal nicht abgeholte Übungsblätter: Kasten vor Raum 277 Zu den üblichen Arbeitszeiten Karatsuba-Ofman-Aufgabe auf ÜB1: Mea Culpa!

4 Roadmap Listen Skip List Hotlist Amortisierte Analyse

5 Verkettete Listen Gut: Einfügen Schlecht: Suchen

6 Listen - Mit Überholspur head head

7 Listen - Mit Überholspur head head Skip Lists Mehrere Levels von verketteten Listen Unterstes Level: Normale Liste Höhere Level: Elemente überspringen Elemente haben eine Höhe Sinnvoll vor allem für sortierte Listen

8 Skip Lists head head Optimale Höhe der Elemente?

9 Skip Lists head head Optimale Höhe der Elemente? height(k) = max{h a Z: a 2 h = k} Simuliert binäre Suche

10 Skip Lists head height(k) = max{h a Z: a 2 h = k} Simuliert binäre Suche

11 Skip Lists head height(k) = max{h a Z: a 2 h = k} Simuliert binäre Suche Pingo Time! Laufzeiten von Suchen und Einfügen?

12 Skip Lists head height(k) = max{h a Z: a 2 h = k} Simuliert binäre Suche Laufzeiten? Suche: O(log n) Iterieren: O(n) Einfügen, Löschen...?

13 Skip Lists Dynamische Datenstruktur? Randomisiert! Höhe h mit Wahrscheinlichkeit p h p = 1? 2

14 Skip Lists Dynamische Datenstruktur? Randomisiert! Höhe h mit Wahrscheinlichkeit p h p = 1? 2 Bei linearen Operationen: aufräumen

15 Skip Lists Dynamische Datenstruktur? Randomisiert! Höhe h mit Wahrscheinlichkeit p h p = 1? 2 Bei linearen Operationen: aufräumen Wie lange dauert das Aufräumen..? Primitive Listen-Operationen: O(1)

16 Skip Lists Dynamische Datenstruktur? Randomisiert! Höhe h mit Wahrscheinlichkeit p h p = 1 2? Bei linearen Operationen: aufräumen Wie lange dauert das Aufräumen..? Primitive Listen-Operationen: O(1) Jedes Element muss in max. log n Listen eingefügt (oder entfernt) werden

17 Skip Lists Dynamische Datenstruktur? Randomisiert! Höhe h mit Wahrscheinlichkeit p h p = 1 2? Bei linearen Operationen: aufräumen Wie lange dauert das Aufräumen..? Primitive Listen-Operationen: O(1) Jedes Element muss in max. log n Listen eingefügt (oder entfernt) werden O(n log n)

18 Skip Lists - Performance Erwartete Komplexität Speicherplatz: O(n)

19 Skip Lists - Performance Erwartete Komplexität Speicherplatz: O(n) Suchen: O(log n)

20 Skip Lists - Performance Erwartete Komplexität Speicherplatz: O(n) Suchen: O(log n) Einfügen, Löschen: O(log n)

21 Skip Lists - Performance Erwartete Komplexität Speicherplatz: O(n) Suchen: O(log n) Einfügen, Löschen: O(log n) Achtung! Kein Worst-Case!

22 Amortisierte Analyse Die Idee Viele schnelle Operationen, wenig langsame Umverteilen der Laufzeit

23 Amortisierte Analyse Die Idee Viele schnelle Operationen, wenig langsame Umverteilen der Laufzeit

24 Amortisierte Analyse Die Idee Viele schnelle Operationen, wenig langsame Umverteilen der Laufzeit

25 Amortisierte Analyse Die Idee Viele schnelle Operationen, wenig langsame Umverteilen der Laufzeit

26 Amortisierte Analyse Die Idee Viele schnelle Operationen, wenig langsame Umverteilen der Laufzeit

27 Amortisierte Analyse - Beispiel Das Ziel Skip List mit Worst-Case-Garantien

28 Amortisierte Analyse - Beispiel Das Ziel Skip List mit Worst-Case-Garantien Annahme: Bei n Elementen nur log n Anfragen

29 Amortisierte Analyse - Beispiel Das Ziel Skip List mit Worst-Case-Garantien Annahme: Bei n Elementen nur log n Anfragen Wir wollen: Einfügen, Anfrage in O ( log 2 n ) (amortisiert!)

30 Amortisierte Analyse - Beispiel Das Ziel Skip List mit Worst-Case-Garantien Annahme: Bei n Elementen nur log n Anfragen Wir wollen: Einfügen, Anfrage in O ( log 2 n ) (amortisiert!) Zur Erinnerung... Einfügen: O(log n) Suchen in optimaler Skip List: O(log n) Aufräumen: O(n log n)

31 Amortisierte Analyse - Beispiel Idee Beim Einfügen keine Mühe geben Vor jeder Anfrage aufräumen

32 Amortisierte Analyse - Beispiel Idee Beim Einfügen keine Mühe geben Vor jeder Anfrage aufräumen Komplexität insgesamt: n c 1 log n + log n c 2 n log n

33 Amortisierte Analyse - Beispiel Idee Beim Einfügen keine Mühe geben Vor jeder Anfrage aufräumen Komplexität insgesamt: n c 1 + log n c 2 n log n

34 Amortisierte Analyse - Erinnerung Achtung, verkürzt! A Op : amortisierte Kosten von Operation Op O T Op : tatsächliche Kosten von Operation Op O Op Berechnung: s 1 Op 0 2 Op s1 3 Op s2 n sn Die angenommenen amortisierten Kosten sind korrekt, wenn c + 1 i n T Opi }{{} tatsächliche Gesamtkosten für eine Konstante c 1 i n A Opi }{{} amortisierte Gesamtkosten

35 Amortisierte Analyse - Beispiel 1 i n T Opi =n c 1 + log n c 2 n log n

36 Amortisierte Analyse - Beispiel 1 i n T Opi =n c 1 + log n c 2 n log n c 1 n log 2 n + c 2 n log 2 n

37 Amortisierte Analyse - Beispiel 1 i n T Opi =n c 1 + log n c 2 n log n c 1 n log 2 n + c 2 n log 2 n =(c 1 + c 2 ) n log 2 n

38 Amortisierte Analyse - Beispiel 1 i n T Opi =n c 1 + log n c 2 n log n c 1 n log 2 n + c 2 n log 2 n =(c 1 + c 2 ) n log 2 n A Opi = n log 2 n + log n log 2 n 1 i n

39 Amortisierte Analyse - Beispiel 1 i n T Opi =n c 1 + log n c 2 n log n c 1 n log 2 n + c 2 n log 2 n =(c 1 + c 2 ) n log 2 n ( ) c 3 A Opi = c 3 (n log 2 n + log n log 2 n ) 1 i n

40 Amortisierte Analyse - Beispiel 1 i n T Opi =n c 1 + log n c 2 n log n c 1 n log 2 n + c 2 n log 2 n =(c 1 + c 2 ) n log 2 n ( ) c 3 A Opi = c 3 (n log 2 n + log n log 2 n ) 1 i n c 3 n log 2 n

41 Hotlist Operationen insert(key k, Data d) lookup(key k) : Data delete(key k) Ziel: jede Operation in amortisiert O( n) Zeit

42 Hotlist n (Unsortierte) Liste der Größe n Sortiertes Array der Größe n n

43 Hotlist - Operationen Lookup lookup(key k) : Data Vorgehen: n durchsuche geordnetes Array mit binärer Suche durchsuche Hotlist komplett n Laufzeit: O ( log n + n ) = O ( n )

44 Hotlist - Operationen insert insert(key k, Data d) n Fall A: in Hotlist ist Platz nächste freie Position in Hotlist n Laufzeit: O(1)

45 Hotlist - Operationen insert insert(key k, Data d) Fall B: in Hotlist ist kein Platz sortiere Hotlist merge: führe sortierte Listen zusammen k erstes Element in neuer Hotlist n n n + n

46 Hotlist - Operationen insert insert(key k, Data d) Fall B: in Hotlist ist kein Platz sortiere Hotlist merge: führe sortierte Listen zusammen k erstes Element in neuer Hotlist Laufzeit: n ) O( 2 + n = O(n) n n n + n

47 Hotlist - Operationen insert insert(key k, Data d) Fall B: in Hotlist ist kein Platz sortiere Hotlist merge: führe sortierte Listen zusammen k erstes Element in neuer Hotlist Pingo Time! Wie schnell sortieren wir n Elemente? n n Laufzeit: n ) O( 2 + n = O(n) n + n

48 Hotlist - Operationen insert insert(key k, Data d) Fall B: in Hotlist ist kein Platz sortiere Hotlist merge: führe sortierte Listen zusammen k erstes Element in neuer Hotlist Laufzeit: O ( n log( n) + n ) = O(n) n n n + n

49 Hotlist - Amortisierung Amortisierung von insert nach Zusammenführung: n 1 Positionen in der Hotlist frei n insert-operationen bis zur nächsten Zusammenführung Zusammenführung hat Aufwand cn Also: spare bei jeder einfachen insert-operation c n an bezahle bei der letzten Operation cn

50 Hotlist - Operationen delete delete(key k): Wenn bisher weniger als O ( n ) Löschoperationen: n n

51 Hotlist - Operationen delete delete(key k): Wenn bisher weniger als O ( n ) Löschoperationen: n jedes Element bekommt valid -Bit lookup: suche k setze valid -Bit auf 0 n Laufzeit: O ( n + log n ) = O ( n )

52 Hotlist - Operationen delete delete(key k): bei mehr als O ( n ) Lösch-Operationen zwischen zwei Zusammenführungen n Vorgehen ähnlich zu insert Reorganisation nach O ( n ) Lösch-Operationen n Laufzeit: Analyse wie bei insert

53 Hotlist - Operationen delete Warum überhaupt löschen?

54 Hotlist - Operationen delete Warum überhaupt löschen? n ist hier: Maximale Anzahl von Elementen in der Hotlist nicht Anzahl Operationen nicht Anzahl gesehene Elemente Ohne Löschen: Datenstruktur wächst unbegrenzt! Laufzeiten gingen kaputt

55 Hotlist - Zusammenfassung insert(key k): Aufwand amortisiert in O ( n ) lookup(key k): Aufwand in O ( n ) delete(key k): Aufwand amortisiert in O ( n )

56 Verkettete Listen

57 Verkettete Listen Einzelner Speicherblock? Allokation dauert Liste über ganzen Speicher verstreut?

58 Verkettete Listen - Drei Arrays key next prev

59 Verkettete Listen - Ein Array

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

61 Variablenwechsel Wie löst man Rekurrenzen der Form T (n) = T ( n) + 1?

62 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

63 Variablenwechsel T (2 m ) = T (2 m 2 ) + 1

64 Variablenwechsel T (2 m ) = T (2 m 2 ) + 1 Trick: setze S(m) := T (2 m ) liefert: ( m ) S(m) = S + 1 2

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

66 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)

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

68 Zusammenfassung Listen Array-Speicherung Skip List Randomisierte Datenstruktur Erwarteter Aufwand O(log n) Aggregat-Methode Hotlist Mischung aus Array und Liste Einfügen, Löschen und Suchen (amortisiert) in O ( n ) Token-Methode