Grundlagen der Algorithmen und Datenstrukturen Kapitel 2

Transkript

1 Grundlagen der Algorithmen und Datenstrukturen Kapitel 2 Christian Scheideler + Helmut Seidl SS Kapitel 3 1

2 Grundlegende Laufzeitanalyse Eingabe (z.b. unsortierte Liste) Eingabe (z.b. Such-Operationen) Algorithmus (z.b. Bubblesort) Datenstrukturoperationen (z.b. Move-to-Front) Ausgabe (z.b. sortierte Liste) Ausgabe (z.b. Such-Liste) Kapitel 2 Kapitel Kapitel 3 2

3 Übersicht Thema: Repräsentation von Sequenzen als Felder und verkettete Listen Was ist eine Sequenz? Repräsentation als Feld und amortisierte Analyse Repräsentation als verkettete Liste Stapel (Stacks) und Schlangen (Queues) Kapitel 3 3

4 Sequenzen Sequenz: s = <e 0,,e n-1 > Arten, auf Element zuzugreifen: Feldrepräsentation: direkter Zugriff über s[i] s[0]: e 0 s[1] s[2] s[3] s[4] s[5]. Listenrepräsentation: indirekter Zugriff über Nachfolger und/oder Vorgänger (Schnitzeljagd durch Speicher) s Nachf. e 0 e 1 Vorg. Nachf. Vorg Kapitel 3 4 e 2 Nachf. Vorg. e 3 Nachf. Vorg..

5 Sequenz als Feld Operationen: <e 0,,e n >.get(i) = e i (analog set(i,e)) <e 0,,e n >.pushback(e) = <e 0,,e n,e> e 0 e 1 e 2 e n e. <e 0,,e n >.popback() = <e 0,,e n-1 > e 0 e 1 e 2 e n-1. (<e 0,,e n-1 >).size() = n Kapitel 3 5

6 Sequenz als Feld Problem: s sei Feld mit 8 Einträgen s-feld andere Daten andere Daten pushback(1), pushback(5), pushback(2) andere Daten andere Daten pushback(6): voll!! Kapitel 3 6

7 Sequenz als Feld Problem: Im vornherein nicht bekannt, wieviele Elemente das Feld enthalten wird Nur Anlegen von statischen Feldern möglich (s = new Elem [w]) Lösung: Datenstruktur für dynamisches Feld Kapitel 3 7

8 3.1 Dynamisches Feld Erste Idee: Jedesmal, wenn Feld s nicht mehr ausreicht (n>w-1), generiere neues Feld der Größe w+c für ein festes c. s[0] s[1] s[2] s[3]. s[w-1] andere Objekte Neues Feld und Umkopieren s[0] s[1] s[2] s[3]. s[w] s[w+1]. s[w+c-1] Kapitel 3 8

9 Dynamisches Feld Zeitaufwand für Erweiterung ist O(w): s[0] s[1] s[2] s[3]. s[w-1] Neues allocate und Umkopieren s[0] s[1] s[2] s[3]. s[w] s[w+1]. s[w+c-1] Zeitaufwand für n pushback Operationen: Aufwand von O(w) je c Operationen Gesamtaufwand: O( i=1 n/c c i) = O(n 2 ) Kapitel 3 9

10 Dynamisches Feld Bessere Idee: Jedesmal, wenn Feld s nicht mehr ausreicht (n>w-1), generiere neues Feld der doppelten Größe 2w. s[0] s[1] s[2] s[3]. s[w-1] s[0] s[1] s[2] s[3]. s[w-1] s[w]. s[2w-1] Jedesmal, wenn Feld s zu groß ist (n<w/4), generiere neues Feld der halben Größe w/ Kapitel 3 10

11 Dynamisches Feld Implementierung als Klasse UArray mit Methode Element get (int i) Methode int size() Methode void pushback(elem e) Methode void popback() Methode void increase(int w) Kapitel 3 11

12 Dynamisches Feld Variablen in Klasse UArray: β = 2; Wachstumsfaktor α = 4; max. Speicheroverhead w=1; momentane Feldgröße n=0; momentane # Elemente b = new Elem [w]; b[0] b[1] b[2] b[3]. b[w-1] Kapitel 3 12

13 Dynamisches Feld Elem get (int i) { assert (0<=i && i<n); return b[i]; int size() { return n; Kapitel 3 13

14 Dynamisches Feld void pushback(elem e) { if (n==w) reallocate(β n); b[n]=e; n=n+1; b b b e n=w=4: Kapitel 3 14

15 Dynamisches Feld void popback() { assert (n>0); n=n-1; b if (α n<=w && n>0) reallocate(β n); b n=5, w=16: Kapitel 3 15

16 Dynamisches Feld void reallocate (int w) { this.w=w; Elem [] b0 = new Elem [w]; for (i=0; i<n; i++) b0[i]=b[i]; b=b0; Umkopieren Kapitel 3 16

17 Dynamisches Feld Lemma 3.1: Betrachte ein anfangs leeres dynamisches Feld s. Jede Folge σ =<σ 1,,σ n > von pushback und popback Operationen kann auf s in Zeit O(n) bearbeitet werden. Erste Idee: Laufzeit O(n 2 ) Nur durchschnittlich konstante Laufzeit pro Operation (Fachbegriff für durchschnittlich : amortisiert) Kapitel 3 17

18 Dynamisches Feld - Analyse Feldverdopplung: Feldhalbierung: Von b b b b Nächste Verdopplung: n pushback Ops Nächste Halbierung: n/2 popback Ops Kapitel 3 18

19 Dynamisches Feld - Analyse Von b Nächste Verdopplung: n pushback Ops Nächste Halbierung: n/2 popback Ops Idee: verrechne reallocate-kosten mit pushback/popback Kosten (ohne realloc) Kosten für pushback/popback: O(1) Kosten für reallocate(β n): O(n) Kapitel 3 19

20 Dynamisches Feld - Analyse Idee: verrechne reallocate-kosten mit pushback / popback Kosten Kontenmethode: Günstige Operationen zahlen Tokens ein. Teure Operationen entnehmen Tokens. Tokenkonto darf nie negativ werden! Kapitel 3 20

21 Dynamisches Feld - Analyse Kontenmethode: Günstige Operationen zahlen Tokens ein! pro pushback 2 Tokens! pro popback 1 Token Teure Operationen entnehmen Tokens! pro reallocate(β n) n Tokens Tokenkonto darf nie negativ werden!! erfüllt über Zeugenargument Kapitel 3 21

22 Dynamisches Feld - Analyse Tokenlaufzeit: Ausführung von push/popback kostet 1 Token! Tokenkosten für pushback: 1+2 = 3! Tokenkosten für popback: 1+1 = 2 Ausführung von reallocate(β n) kostet n Tokens! Tokenkosten für reallocate(β n): n-n=0 pushb pushb pushb pushb reallocate Gesamtlaufzeit = O(Summe der Tokenlaufzeiten) Kapitel 3 22

23 Sequenzen Sequenz: s = <e 0,,e n-1 > Arten, auf Element zuzugreifen: Feldrepräsentation: direkter Zugriff über s[i] s[0]: e 0 s[1] s[2] s[3] s[4] s[5]. Listenrepräsentation: indirekter Zugriff über Nachfolger und/oder Vorgänger s Nachf. e 0 e 1 Vorg. Nachf. Vorg Kapitel 3 23 e 2 Nachf. Vorg. e 3 Nachf. Vorg..

24 Doppelt verkettete Liste Interne Speicherung (3 Elemente): s e 0 V N e 2 V N e 1 V N Variable s speichert Startpunkt der Liste Wie Schnitzeljagd im Speicher Kapitel 3 24

25 Doppelt verkettete Liste class Item<Elem> { Elem e; Item<Elem> next; Item<Elem> prev; e e e class List<Elem> { Item<Elem> h; weitere Variablen und Methoden Invariante: (this: Zeiger auf aktuelles Element) next.prev == prev.next == this Kapitel 3 25

26 Doppelt verkettete Liste Einfache Verwaltung: durch Dummy -Element mit Inhalt null:? e 1 e 2 e n Anfangs:? Kapitel 3 26

27 Doppelt verkettete Liste Zentrale statische Methode: splice splice entfernt <a,,b> aus Sequenz und fügt sie hinter einem t an. Bedingung: <a,,b> muss eine Teilsequenz sein, b ist nicht vor a, und t darf nicht in <a,,b> stehen. Für <e 1,,a,a,,b,b,,t,t,e n > liefert splice (a, b, t) = <e 1,,a,b,,t,a,,b,t,,e n > Kapitel 3 27

28 Doppelt verkettete Liste static void splice(item<elem> a, Item<Elem> b,item<elem> t) { // schneide <a,,b> heraus Item<Elem> a' = a.prev; Item<Elem> b' = b.next; a'.next = b ; b'.prev = a'; // füge <a,,b> hinter t ein Item<Elem> t' = t.next; b.next = t'; a.prev = t; t.next = a; t'.prev = b; a a b b t a b t Kapitel 3 28

29 Doppelt verkettete Liste h: Item mit null Methoden: Item<Elem> head() { return h; boolean isempty() { return h.next == h; Item<Elem> first() { return h.next; Item<Elem> last() { return h.prev;? Kapitel 3 29 e 1? e n Kann evtl. auf?-element zeigen! Kann evtl. auf?-element zeigen!

30 Doppelt verkettete Liste h: Item mit null? e 1 e n Methoden: static void moveafter(item<elem> b, Item<Elem> a) { splice(b,b,a); // schiebe b nach a void movetofront(item<elem> b) { moveafter(b,head()); // schiebe b nach vorn // analog movetoend Kapitel 3 30

31 Doppelt verkettete Liste Löschen und Einfügen von Elementen: mittels extra Liste freelist static void remove(item<elem b) { moveafter(b, freelist.head()); void popfront() { remove(first()); void popback() { remove(last()); Kapitel 3 31 h freelist b freelist: gut für Laufzeit, da Speicherallokation teuer

32 Doppelt verkettete Liste static Item<Elem> insertafter(elem x, Item<Elem> a){ Item<Elem> a'; if (freelist.isempty()) a' = new Item<Elem>(); else a' = freelist.first(); moveafter(a', a); a'.e = x; return a'; static Item<Elem> insertbefore(elem e, Item<Elem> b) { return insertafter(e, b.prev); void pushfront(elem e) { insertafter(e, head()); void pushback(elem e) { insertafter(e, last()); h a a x Kapitel 3 32

33 Doppelt verkettete Liste Manipulation ganzer Listen: void concat(list<elem> l) { if (! l.isempty()) splice(l.first(), l.last(), last()); h l last Kapitel 3 33

34 Doppelt verkettete Liste Suche nach einem Element: Trick: verwende Dummy -Element x e 1 e n Item<Elem> findnext (Elem x, Item<Elem> from) { h.e = x; while (from.e!= x) from = from.next; h.e = null; return from; Kapitel 3 34

35 Einfach verkettete Liste class Sitem <Elem> { Elem e; Sitem<Elem> next;? e e class Slist<Elem> { Sitem<Elem> h; weitere Variablen und Methoden Kapitel 3 35

36 Einfach verkettete Liste static void splice(sitem a', Sitem b, Sitem t) { Sitem a = a'.next; a'.next = b.next; b.next = t.next; t.next = a; a a b b t t Kapitel 3 36

37 Stacks und Queues Grundlegende Datenstrukturen für Sequenzen: Stack FIFO-Queue: Kapitel 3 37

38 Stack Methoden: pushback: <e 0,,e n >.pushback(e) = <e 0,,e n,e> popback: <e 0,,e n >.popback() = <e 0,,e n-1 > last: <e 0,,e n >.last() = e n Implementierungen auf vorherigen Folien Kapitel 3 38

39 FIFO-Queue Methoden: pushback: <e 0,,e n >.pushback(e) = <e 0,,e n,e> popfront: <e 0,,e n >.popfront() = <e 1,,e n > first: <e 0,,e n >.first() = e 0 Implementierungen auf vorherigen Folien Kapitel 3 39

40 Beschränkte FIFO-Queue class BoundedFIFO <Elem> { Elem[] b; int h=0; // Index des ersten Elements int t=0; // Index des ersten freien Eintrags boolean isempty() { b return h == t; h Elem first() { pop return b[h]; int size() { return (t-h+n+1) % (n+1); 0 n t push Kapitel 3 40

41 Beschränkte FIFO-Queue class BoundedFIFO<Elem> { Elem[] b; int h=0; // Index des ersten Elements int t=0; // Index des ersten freien Eintrags... void pushback(elem x) { b assert (size() < n); b[t] = x; h t = (t+1) % (n+1); pop void popfront() { assert (!isempty()); h = (h+1) % (n+1); 0 n t push Kapitel 3 41

42 Fazit Listen sind sehr flexibel, wenn es darum geht, Elemente in der Mitte einzufügen Felder können in konstanter Zeit auf jedes Element zugreifen Listen haben kein Reallokationsproblem bei unbeschränkten Größen! beide Datenstrukturen einfach, aber oft nicht wirklich zufriedenstellend Kapitel 3 42

43 Beispiel: Sortierte Sequenz Problem: bewahre nach jeder Einfügung und Löschung eine sortierte Sequenz insert(5) remove(14) Kapitel 3 43

44 Beispiel: Sortierte Sequenz Warum sortierte Sequenz? Mit Feld binäre Suche möglich (Kapitel 2). find(23): In n-elementiger Folge kann jedes Element in max. log n Schritten gefunden Kapitel 3 44

45 Beispiel: Sortierte Sequenz S: sortierte Sequenz Jedes Element e identifiziert über key(e). Operationen: <e 0,,e n >.insert(e) = <e 0,,e i,e,e i+1,,e n > für das i mit key(e i ) < key(e) < key(e i+1 ) <e 0,,e n >.remove(k) = <e 0,,e i-1,e i+1,,e n > für das i mit key(e i )=k <e 0,,e n >.find(k) = e i für das i mit key(e i )=k Kapitel 3 45

46 Beispiel: Sortierte Sequenz Realisierung als Liste: insert, remove und find auf Sequenz der Länge n kosten im worst case Θ (n) Zeit Realisierung als Feld: insert und remove kosten im worst case Θ (n) Zeit find kann so realisiert werden, dass es im worst case nur O(log n) Zeit benötigt (! binäre Suche!) Kapitel 3 46

47 Beispiel: Sortierte Sequenz Kann man insert und remove besser mit einem Feld realisieren? folge Beispiel der Bibliothek! verwende Hashtabellen (Kapitel 4) Kapitel 3 47

48 Beispiel: Sortierte Sequenz Bibliotheksprinzip: lass Lücken! Angewandt auf sortiertes Feld: insert(5) remove(14) Kapitel 3 48

49 Beispiel: Sortierte Sequenz Durch geschickte Verteilung der Lücken: amortierte Kosten für insert und remove Θ (log 2 n) insert(5) remove(14) Kapitel 3 49

50 Beispiel: Sortierte Sequenz Insert, delete und find noch viel effizienter umsetzbar, wie wir sehen werden! Kapitel 3 50

51 Nächstes Kapitel Wörterbuchproblem Hashing Statische Wörterbücher Dynamische Wörterbücher Kapitel 3 51