Algorithmen und Datenstrukturen 3. Vorlesung

Transkript

1 Algorithmen und Datenstrukturen 3. Vorlesung Martin Dietzfelbinger 18. April 2005 Stacks Queues Listen... Datentypen und Datenstrukturen FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Spezifikation des Datentyps Stack über U 1. Signatur: Sorten: Keys Stacks Boolean Operationen: empty: Stacks push: Stacks Keys Stacks pop: Stacks Stacks top: Stacks Keys isempty: Stacks Boolean Mathematisches Modell Sorten: Keys: (nichtleere) Menge U (Parameter) Stacks: U < = Seq(U) wo Seq(U) = {(a 1,...,a n ) n N,a 1,...,a n U} Boolean: {true, false} Operationen: FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

2 empty(()) = () push((a 1,...,a n ),x) := (x,a 1,...,a n ) { (a2,...,a n ), falls n 1 pop((a 1,...,a n )) := undefiniert, falls n = 0 { a1, falls n 1 top((a 1,...,a n )) := undefiniert, falls n = 0 { false, falls n 1 isempty((a 1,...,a n )) := true, falls n = 0 Implementierungsmöglichkeiten Array A[1..m] of Keys und Pegelvariable p: int (einfach) verkettete lineare Liste FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Listenimplementierung Siehe GdP 1, 8. Vorlesung, Organisationsform 1 s: 1 2 a a (Das Symbol steht fur " den Nullzeiger. ) empty: Kreiere leere Liste. push(x): Füge neues Listenelement mit Eintrag x ein. pop: Entferne erstes Listenelement (falls vorhanden) top: Gib Inhalt des ersten Listenelements aus (falls vorhanden) isempty: Falls Liste leer: Ausgabe true, sonst false Einzige Fehlermöglichkeit: Speicher-Überlauf. a n Korrektheit der Listenimplementierung Behauptung: Die Listenimplementierung erzeugt genau dieselbe Ausgabefolge wie das mathematische Modell, solange weder im mathematischen Modell ein Fehler (top oder pop auf leerem Stack) auftritt noch ein Laufzeitfehler Speicherüberlauf auftritt. Beweis: Man zeigt per Induktion über i, dass nach Ausführen der Operation Op i folgendes gilt: Die Einträge in der Liste sind genau die Einträge in s i die Liste ist eine präzise Darstellung von s i. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

3 Zeitaufwand bei Listenimplementierung Behauptung: Bei der Listenimplementierung hat jede einzelne Operation Kosten O(1). Das ist klar. Kosteneinheit allerdings: Allokation eines Listenelements Systemaufruf ( malloc in C) um einiges teurer als Arrayzugriff. Vorteile der Arrayimplementierung: Sequentieller Zugriff im Speicher. Listenimplementierung benötigt zusätzlichen Speicherplatz für Zeiger. Arrayimplementierung ohne Platzprobleme? Verdoppelungsstrategie In push(x): Bei Überlaufen des Arrays A nicht einen Laufzeitfehler (oder eine exception) generieren, sondern ein neues, doppelt so großes Array AA allokieren. Variable m: int enthält aktuelle Größe m des Arrays. Einträge aus A nach AA kopieren. AA in A umbenennen. Kosten: c m, wo m = aktuelle Zahl der Einträge. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Kostenanalyse bei Verdoppelungsstrategie: Operationenfolge Op 0 = empty, Op 1,..., Op N Arraygröße am Anfang: m 0. Jede Operation hat Kosten O(1), außer wenn die Arraygröße von m 0 2 i 1 auf m 0 2 i wächst. Hier entstehen Kosten Θ(m 0 2 i 1 ). k := Anzahl der push-operationen in Op 1,..., Op N Zahl der Einträge immer k, also bei Verdopplung m 0 2 i 1 m 0 2 i : m 0 2 i 1 < k. Sei L maximal mit m 0 2 L 1 < k. Gesamtkosten für die Verdopplungen also: O(m 0 2 i 1 ) 1 i L = O ( m 0 ( L 1 ) ) = O ( m 0 2 L) = O(k). Gesamtkosten: N O(1) + O(k) = O(N + k) = O(N). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

4 Satz Wenn ein Stack mit Arrays und der Verdoppelungsstrategie implementiert wird, betragen die Gesamtkosten für N Operationen O(N). Bemerkung: Bei der Verdoppelungsstrategie gilt weiter: Der gesamte Platzbedarf ist O(k), wenn k die maximale je erreichte Stackhöhe ist. Selbst wenn der Speicher nie bereinigt wird, tritt ein Speicherüberlauf erst ein, wenn die Zahl der Stackeinträge zu einem bestimmten Zeitpunkt mehr Speicher beansprucht als 1 4 des gesamten zur Verfügung stehenden Speichers. Queues Warteschlangen FIFO-Listen First-In-First-Out Idee (siehe GdP-Vorlesung): isempty: false first: 3 enqueue(9) dequeue FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Signatur: Übung Mathematisches Modell: Übung Implementierung mittels einfach verketteter linearer Listen: Übung Implementierung mittels Arrays, zirkulär benutzt: A[0..m 1] m 2 m head: tail: i j head: tail: i j FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

5 empty: Erzeuge Array A[0..m 1] of Keys und 2 Variable head,tail: int ; head 0; tail 0; isempty: if head = tail then return true else return false ; first: if head = tail then Fehler (z.b. QEmptyException) else return A[head] ; dequeue: if head = tail then Fehler (z.b. QEmptyException) else head (head + 1) mod m ; enqueue(x): tt (tail + 1) mod m; if tt = head then Fehler (z.b. OverflowException) else tail tt ; A[tail] x ; FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Alternative zu Overflow-Exception: Erzeugen eines neuen Arrays AA der Größe 2m; Umkopieren der Einträge A[head], A[(head + 1 mod m)],..., A[tail] in AA[0], AA[1],..., AA[m 1]; head 0; tail m 1; Satz Wenn eine Queue mit Arrays und der Verdoppelungsstrategie implementiert wird, sind die Gesamtkosten für N Operationen O(N). Bemerkung: Bei der Verdoppelungsstrategie gilt weiter: Der gesamte Platzbedarf ist O(k), wenn k die maximale je erreichte Länge der Queue ist. Umbenennen von AA in A. Dann: Anhängen von x. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

6 Einfachste Datenstrukturen für (endliche) Mengen Modelliere: Endliche Mengen über U. Intuitive Aufgabe: Speichere S U, S endlich, mit Operationen Initialisierung: S ; Suche: x S?; Hinzufügen: S S {x}; Löschen: S S {x}. 1. Signatur: Datentyp Dynamische Menge Sorten: Keys Sets Boolean Operationen: empty: Sets insert: Sets Keys Sets delete: Sets Keys Sets member: Sets Keys Boolean Statt member findet man auch oft den Namen lookup FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Datentyp Dynamische Menge 2. Mathematisches Modell: Modellierung einer Menge als endliche Menge von Objekten: Sorten: Keys: (nichtleere) Menge U (Parameter) Sets: P < (U) = {S U S endlich} Boolean: {true, false} Datentyp Dynamische Menge Operationen: empty(()) = insert(s, x) := S {x} delete(s, x) := S {x} { true, falls x S member(s, x) := false, falls x / S FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

7 Beachte: Datentyp Dynamische Menge Ganz nebenbei wird das Verhalten des Datentyps bei den Sonderfällen bei insert(s, x) ist x schon in S bei delete(s, x) ist x nicht in S ohne Möglichkeit von Missverständnissen spezifiziert. Implementierungsmöglichkeiten (A) Einfach verkettete Liste oder Array mit Wiederholung : {1,2,5,7,11} darstellbar als list: bzw h 11 7 * * * m * * * * pegel: h FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Operationen: empty: erzeuge leere Liste / leeres Array A[1..m] member(x): durchsuche Liste / Array nach (erstem Auftreten von) x insert(x): füge x vorne in Liste ein bzw. füge x an Pegelposition in Array ein delete(x): suche und entferne alle Vorkommen von x in Liste bzw. Array Wie vermeidet man das Entstehen von Lücken im Array? Wenn A[j] zu entfernen ist: A[j] A[pegel]; pegel--; Operationen mit Zeitbedarf h = gegenwärtige Pegelhöhe/Listenlänge empty: erzeuge leere Liste / leeres Array A[1..m] O(1) member(x): durchsuche Liste / Array nach (erstem Auftreten von) x O(h) insert(x): füge x vorne in Liste ein bzw. füge x an Pegelposition in Array ein O(1) delete(x): suche und entferne alle Vorkommen von x in Liste bzw. Array O(h) Nachteil: Wenn sehr oft schon vorhandene Elemente eingefügt werden, kann der Umfang der Liste viel größer als S werden, mit entsprechenden Auswirkungen auf Platzbedarf und Zeitaufwand. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

8 (B) Einfach verkettete Liste oder Array ohne Wiederholung: Mögliche Darstellung der Menge {1, 2, 3, 5, 7, 8, 11}: list: bzw (B) Einfach verkettete Liste oder Array ohne Wiederholung: Vorteil: Platz für S U ist genau S Array-/Listeneinträge. Nachteil: Bei insert, delete, member jeweils lineare Suche nötig. Rechenaufwand in allen Fällen Θ( S ) h * * * m * * * * pegel: h Variable pegel enthält stets S FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD (C) Einfach verkettete Liste oder Array aufsteigend sortiert nur möglich bei angeordnetem Universum (U,<): Darstellung der Menge {1, 2, 3, 5, 7, 8, 11}: list: bzw Einfach verkettete Liste aufsteigend sortiert: Vorteil: Kann Suche nach x abbrechen, sobald ein Listen-/Arrayeintrag x erreicht wird. Mittlere Anzahl von Vergleichen bei Suche nach einem der Einträge a 1 < < a n : wenn für jedes i gilt: Pr(x = a i ) = 1 n 1 * * * pegel: h Variable pegel enthält stets S h m * * * * ( n) 1 n = n FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

9 Mittlere Anzahl von Vergleichen bei Suche nach einem x / {a 1,...,a n } (1 Vergleich für Entscheidung zwischen <,=,>): wenn gilt: für jedes i ist Pr(a i 1 < x < a i ) = 1 n+1 und Pr(x < a 1 ) = Pr(a n < x) = 1 n+1 : ( n + n) 1 n + 1 < n Dies gilt ebenfalls für die Einfüge- und die Lösch-Operation. Array, aufsteigend sortiert: Nachteil: insert, delete: Verschieben vieler Elemente nötig, um die Ordnung zu erhalten und dabei das Entstehen von Lücken zu vermeiden. Zeitaufwand: Θ( S ) Vorteil: member: Kann binäre Suche benutzen. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Binäre Suche, rekursiv Aufgabe: Suche Objekt x in Teilarray A[a..b] Idee: 0. Falls b < a, ist x nicht im Teilarray 1. Falls a = b, ist x in A[a..b], falls x = A[a], sonst nicht 2. Falls a < b, berechne m = (a+b)/2 (Mitte des Teilarrays) 3 Fälle: x = A[m]: gefunden x < A[m]: Wende Binäre Suche auf A[a..m 1] an x > A[m]: Wende Binäre Suche auf A[m + 1..b] an Suche nach x in A[1..h]: Binäre Suche in A[1..h] Gegeben: Array A[1..M], x: Keys; Prozedur RecBinSearch Eingabe: a,b: int; ( 1 a M + 1, 0 b M ) (1) if b < a then return false; (2) if a = b then return (x = A[a]); (3) m (a+b) div 2 ; (4) if x = A[m] then return true; (5) if x < A[m] then return RecBinSearch(a,m-1); (6) if x > A[m] then return RecBinSearch(m+1,b). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

10 Gegeben: Array A[1..M], x: Keys; Algorithmus Binäre Suche (rekursiv) Eingabe: Array A[1..M], x: Keys; h, 1 h M, mit A[1] < < A[h]; (1) return RecBinSearch(1, h) Korrektheit von Prozedur RecBinSearch: Proposition Das Teilarray A[a..b] von A[1..M] sei strikt aufsteigend sortiert, und es gelte 1 a M + 1,0 b M. Dann gilt: Der Aufruf RecBinSearch(a,b) liefert das Resultat true, falls x in A[a..b] vorkommt, false, falls nicht. Beweis: ( ) Die Aussage stimmt, falls a > b (Zeile (1)) Für den Fall a b benutzen wir verallgemeinerte Induktion. Behauptung: (I.B.) Wenn b a = i, dann liefert der Aufruf RecBinSearch(a, b) mit 1 a, b M das korrekte Resultat. Basis: i = 0. Dann ist a = b, und die Ausgabe ist korrekt (Zeile (2)). FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Ind.-Vor.: Die (I.B.) gilt für alle Aufrufe RecBinSearch(c, d) mit d c < i. Ind.-Schritt: Sei i > 0. Dann ist a < b. Es wird m = (a + b)/2 berechnet. Beobachte: a m < b. Fall 1: x = A[m]. Ausgabe korrekt (Zeile (4)) Fall 2: x < A[m]. Beobachte: Wenn x in A[a..b] vorkommt, dann nicht in A[m..b], denn A[a..b] ist aufsteigend sortiert. Es genügt also, x im restlichen Teil von A[a..b] zu suchen. Wir folgern: Der rekursive Aufruf RecBinSearch(a, m 1) in Zeile (5) liefert das korrekte Resultat. (Beachte: m 1 0.) Wieso? Falls m 1 < a: ( ). Falls m 1 a, ist (m 1) a < b a = i, also können wir die (I.B.) für (a, m 1) anwenden. Diese sagt: Aufruf RecBinSearch(a,m 1) liefert true, falls x in A[a..m 1] vorkommt, false sonst. Fall 3: x > A[m] Überlege analog zu Fall 2, benutze Induktionsvoraussetzung. Satz Rekursive Binäre Suche auf einem strikt aufsteigend geordneten Array A[1..h] liefert das korrekte Ergebnis. Beweis: Direkt aus der Proposition. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

11 Laufzeit von Prozedur RecBinSearch: T RBS (n) seien die worst-case Kosten für einen Aufruf Rec- BinSearch(a,b) mit n = b a + 1 (maximiert über alle möglichen Arrays A[a..b] und Indexpaare (a,b)) Jeder Aufruf von RecBinSearch verursacht Kosten C für eine Konstante C, wenn man die Kosten der hiervon ausgelösten rekursiven Aufrufe nicht zählt. Gesucht also, für alle n: r(n) = maximale Anzahl der Aufrufe, inklusive des ersten Aufrufs, wenn b a + 1 = n. Klar: Wenn n 1, ist r(n) = 1. Für n 2: Die rekursiven Aufrufe beziehen sich auf Teilarrays der Länge (n 1)/2 (links) oder (n 1)/2 (rechts). Dies liefert folgende Rekursionsformel: r(n) 1 + max{r( (n 1)/2 ),r( (n 1)/2 )}. Behauptung: r(n) 1 + log n, für n 1. Beweis: Verallgemeinerte Induktion. Korrekt für n = 1, weil log 1 = 0. Nun sei n 2. Nach Rekursionsformel: r(n) 1 + max{r( (n 1)/2 ),r( (n 1)/2 )}. Falls n = 2, heißt das r(2) 1 + max{r(0),r(1)} = 2 = 1 + log 2. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD Falls n 3, ist (n 1)/2 (n 1)/2 1, also (nach Induktionsvoraussetzung) r(n) 1 + max{1 + log( (n 1)/2 ),1 + log( (n 1)/2 )}. Weil (n 1)/2 n/2, folgt dann r(n) log(n/2) = 1 + log n; das ist die Induktionsbehauptung. Beispiel: Arraygröße erfordert etwa 23 rekursive Aufrufe für eine Suche. Mehrere Mengen: Datentyp DynSets Intuitive Aufgabe: Speichere mehrere Mengen S 1,...,S r U, so dass für jede die Operationen des Datentyps DynSet ausführbar sind und zudem Vereinigung, Durchschnitt, Differenz, Symmetrische Differenz Signatur: Wie DynSet, und zusätzlich: union : Sets Sets Sets intersection : Sets Sets Sets diff : Sets Sets Sets symdiff : Sets Sets Sets FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

12 Mathematisches Modell: Wie DynSet, und zusätzlich: union(s 1,S 2 ) := S 1 S 2 intersection(s 1,S 2 ) := S 1 S 2 diff (S 1,S 2 ) := S 1 S 2 symdiff (S 1,S 2 ) := (S 1 S 2 ) (S 2 S 1 ) Implementierung des Datentyps DynSets: Im Prinzip dieselben Möglichkeiten wie bei DynSet. einfach: ungeordnete Strukturen (Array/Liste) ohne Wiederholung. Implementierungen der vier Operationen: Für jedes Element von S 1 durchsuche Darstellung von S 2. Rechenzeit: Θ(n 1 n 2 ), wo S 1 = n 1, S 2 = n 2. FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD clever: aufsteigend sortierte Arrays/Listen. Implementierungen der vier Operationen: Rechenzeit: Θ(n 1 + n 2 ), wo S 1 = n 1, S 2 = n oo oo oo oo oo oo Mischen (wie merge bei Mergesort) FG KTuEA, TU Ilmenau AuD FG KTuEA, TU Ilmenau AuD

13 FG KTuEA, TU Ilmenau AuD