Übung Algorithmen I

Transkript

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

2 Roadmap Listen Skip List Hotlist Amortisierte Analyse

3 Verkettete Listen Gut: Einfügen Schlecht: Suchen

4 Listen - Mit Überholspur head head

5 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

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

7 Skip Lists head head Optimale Höhe der Elemente? height(k) = max{h a Z: a 2 h = k} Bei jedem Schritt wird der Suchraum halbiert

8 Skip Lists head height(k) = max{h a Z: a 2 h = k} Bei jedem Schritt wird der Suchraum halbiert

9 Skip Lists head height(k) = max{h a Z: a 2 h = k} Bei jedem Schritt wird der Suchraum halbiert Laufzeiten?

10 Skip Lists head height(k) = max{h a Z: a 2 h = k} Bei jedem Schritt wird der Suchraum halbiert Laufzeiten? Suche: O(log n) Iterieren: O(n) Einfügen, Löschen...?

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

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

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

14 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

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) Jedes Element muss in max. log n Listen eingefügt (oder entfernt) werden O(n log n)

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

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

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

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

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

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

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 - Beispiel Das Ziel Skip List mit Worst-Case-Garantien

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

27 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!)

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

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

30 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

31 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

32 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

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

34 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

35 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

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 =(c 1 + c 2 ) n log 2 n A Opi = n log 2 n + log n log 2 n 1 i 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 ( ) c 3 A Opi = c 3 (n log 2 n + log n log 2 n ) 1 i 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 ( ) c 3 A Opi = c 3 (n log 2 n + log n log 2 n ) 1 i n c 3 n log 2 n

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

40 Hotlist n (Unsortierte) Liste der Gröÿe n Sortiertes Array der Gröÿe n n

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

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

43 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

44 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 + n ) = O(n) n n n + n

45 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

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

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

48 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

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

50 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

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

52 Zusammenfassung 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

53 Verkettete Listen

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

55 Verkettete Listen - Drei Arrays key next prev

56 Verkettete Listen - Ein Array

57 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

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

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

60 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

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

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

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

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

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

66 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