Datenstrukturen Mariano Zelke Sommersemester 2012
Mathematische Grundlagen: Das Handwerkszeug Mariano Zelke Datenstrukturen 2/26 Formeln: n - i = n (n+1) 2 und - i=1 k i=0 a i = ak+1 1 a 1, falls a 1 Rechnen mit Logarithmen: Es gelte a, b > 1 und x, y > 0 seien reelle Zahlen. Dann ist 1. log a (x y) = log a x + log a y 2. log a (x y ) = y log a (x) 3. a log a x = x 4. log a x = (log a b) (log b x) 5. b log a x = x log a b
Die asymptotische Notation Mariano Zelke Datenstrukturen 3/26 f, g : N R 0 seien Funktionen, die einer Eingabelänge n N eine nicht-negative Laufzeit f (n), bzw. g(n) zuweisen. Die Groß-Oh Notation: f = O(g) Es gibt eine positive Konstante c > 0 und eine natürliche Zahl n 0 N, so dass f (n) c g(n) für alle n n 0 gilt: f wächst höchstens so schnell wie g. f = Ω(g) g = O(f ) : f wächst mindestens so schnell wie g. f = Θ(g) f = O(g) und g = O(f ) : f und g wachsen gleich schnell. Die Klein-Oh Notation: f = o(g) lim langsamer als g. n f (n) g(n) = 0: f wächst g(n) f = ω(g) lim n f (n) = 0: f wächst schneller als g.
Asymptotik Mariano Zelke Datenstrukturen 4/26 Der Grenzwert der Folge f (n) g(n) 1. Wenn c = 0, dann ist f = o(g) 2. Wenn 0 < c <, dann ist f = Θ(g) 3. Wenn c =, dann ist f = ω(g) 4. Wenn 0 c <, dann ist f = O(g) 5. Wenn 0 < c, dann ist f = Ω(g) f (n) möge existieren und es sei lim n g(n) = c.
Wachstums-Hierarchie Mariano Zelke Datenstrukturen 5/26 Es seien a > 1, b > 1 und k > 1 Konstanten. Dann bilden die folgenden Funktionen von N >0 nach R 0 eine Wachstumshierarchie: n! b n n k n log 2 n n n 1/k log a n log (k) a n 1 wächst asymptotisch schneller
Das Lösen von Rekursionsgleichungen Mariano Zelke Datenstrukturen 6/26 Mastertheorem: Die Rekursion T (1) = c, T (n) = at ( n b ) + t(n) ist zu lösen, wobei b > 1, a 1, c > 0. - Wenn t(n) = O ( n (log b a) ε) für eine positive Konstante ε > 0, dann ist T (n) = Θ(n log b a ) - Wenn t(n) = Θ(n log b a ), dann ist T (n) = Θ(n log b a log b n) - Wenn t(n) = Ω ( n (log a)+ε) b für eine positive Konstante ε > 0 und a t ( ) n b αt(n) für eine Konstante α < 1, dann ist T (n) = Θ(t(n)) Wann ist es anwendbar? Wann nicht? (Beispiel: Türme von Hanoi) Was tun, wenn nicht?
Laufzeitbestimmung von C++ Programmen Mariano Zelke Datenstrukturen 7/26 Zuweisungen: Eine Zuweisung zu einer einfachen Variablen ist einfach zu zählen, eine Zuweisung zu einer Array-Variablen ist mit der Länge des Arrays zu gewichten. Auswahl-Anweisungen: Häufig genügt: Bedingung + Gesamtaufwand für den längsten der alternativen Anweisungsblöcke. Schleifen: Häufig genügt: Maximale Anzahl der auszuführenden Anweisungen innerhalb einer Schleife Anzahl der Schleifendurchläufe
Elementare Datenstrukturen: Listen, Stacks und Queues Mariano Zelke Datenstrukturen 8/26 Listen passen sich der Größe der zu speichernden Datenmenge dynamisch an. Wenn die Position eines einzufügenden oder zu entfernenden Elements bekannt ist, dann gelingt die Operation schnell. Muss nach der Position gesucht werden, dann ist die Laufzeit fürchterlich. Die Adjazenzlistendarstellung von Graphen ist eine wichtige Anwendung. Stacks: Einfügen und Entfernen des jüngsten Elements, beide Operationen gelingen schnell. Stacks finden zum Beispiel in der Implementierung der Rekursion eine wichtige Anwendung. Queues: Einfügen und Entfernen des ältesten Elements, beide Operationen gelingen schnell. Queues modellieren Warteschlangen. Eine wichtige Anwendung ist die Implementierung der Breitensuche. Deques: Verallgemeinern Stacks und Queues
Bäume Mariano Zelke Datenstrukturen 9/26 Als gerichteter Graph: alle Knoten müssen von der Wurzel aus erreichbar sein; zusätzlich hat jeder Knoten höchstens eine eingehende Kante Als ungerichteter Graph: ein Baum ist ein zusammenhängender, kreisfreier Graph Wichtige Datenstrukturen: Vater-Array (wenn nur das Hochklettern im Baum unterstützt werden muss), Binärbaum-Darstellung, Kind-Geschwister-Implementierung (wenn ein schneller Zugriff auf die Kinder erforderlich ist) Bäume können zum Beispiel mit dem Präorder-, Postorder- und Inorder-Verfahren durchlaufen werden. Die Verfahren sind schnell: Zeit O(n) für Bäume mit n Knoten Anwendungen dieser Verfahren sind zum Beispiel die Berechnung der Tiefe des Baumes, bzw. die Berechnung der Anzahl der Blätter
Graphen Tiefensuche Adjazenzlistendarstellung: für viele Anwendungen (z.b. das Navigieren in Graphen) ausreichend. Vorteile: schnelle Bestimmung aller Nachbarn bzw. aller direkten Nachfolger Tiefensuche void tsuche(int v){ Knoten *p; besucht[v] = 1; for (p = A[v]; p!=0; p = p->next) if (!besucht [p->name]) tsuche(p->name);} Ein Aufruf von Tiefensuche für Knoten w, bei ausschließlich unmarkierten Knoten, besucht alle von w aus erreichbaren Knoten Tiefensuche für Graphen G = (V, E) ist schnell: Laufzeit O( V + E ). Die Baumkanten definieren den Wald der Tiefensuche. Ungerichtete Graphen besitzen neben den Baumkanten nur Rückwärtskanten. Gerichtete Graphen besitzen Baum- und Vorwärtskanten sowie Rückwärts- und rechts-nach-links Querkanten. Mariano Zelke Datenstrukturen 10/26
Anwendungen der Tiefensuche Mariano Zelke Datenstrukturen 11/26 Ungerichtete Graphen: Schnelle Antwort auf die Fragen, ob ein Graph ein Baum, ein Wald oder zusammenhängend ist Die Bäume des Waldes der Tiefensuche entsprechen den Zusammenhangskomponenten des Eingabegraphen. Gerichtete Graphen: Schnelle Antwort auf die Fragen, ob ein Graph azyklisch oder stark zusammenhängend ist, bzw. die Berechnung einer topologischen Sortierung
Breitensuche für Graphen G = (V, E) ist schnell: Zeit O( V + E ) Ein Aufruf von Breitensuche für Knoten w erzeugt über die Baumkanten einen Baum kürzester Wege vom Startknoten w zu allen von w aus erreichbaren Knoten Anhand dieses Baumes der Breitensuche lassen sich Rückwärts- und Querkanten in G klassifizieren. Mariano Zelke Datenstrukturen 12/26 Graphen Breitensuche void Breitensuche(int v){ Knoten *p; int w; queue q; for (int k =0; k < n ; k++) besucht[k] = 0; q.enqueue(v); besucht[v] = 1; while (!q.empty( )){ w = q.dequeue( ); for (p = A[w]; p!= 0; p = p->next) if (!besucht[p->name]){ q.enqueue(p->name); besucht[p->name] = 1;}}}
Prioritätswarteschlangen insert, delete max, change priority, remove. Heaps speichern die Prioritäten mit Heap-Struktur und Heap-Ordnung ab. Insbesondere: die an Knoten v abgespeicherte Priorität ist den von den beiden Kindern gespeicherten Prioritäten: Größte Priorität also an der Wurzel! Heap-Struktur garantiert, dass der Heap n Prioritäten durch n aufeinanderfolgende Zellen abspeichern kann. Insbesondere: wenn die Priorität des Knotens v in Position i abgespeichert ist, dann wird die Priorität des linken Kindes in Position 2 i und die Priorität des rechten Kindes in Position 2 i + 1 gespeichert. Die Priorität des Vaters befindet sich in Position i/2. Die einzelnen Operationen werden mit Hilfe der Operationen repair up und repair down implementiert. Sämtliche Operationen auf einem Heap mit n Prioritäten benötigen nur Laufzeit O(log 2 n). Mariano Zelke Datenstrukturen 13/26
Anwendung von Prioritätswarteschlangen Mariano Zelke Datenstrukturen 14/26 Implementierung zahlreicher Algorithmen, typischerweise: falls wiederholt kleinste oder größte Schlüssel zu bestimmen und Aktualisierungsschritte auszuführen sind Fundamentales Beispiel: die Implementierung des Algorithmus von Dijkstra Weitere Beispiele: Implementierungen der Algorithmen für minimale Spannbäume Prim Kruskal (hier auch: Union-Find-Datenstruktur) Heapsort
Der abstrakter Datentyp Wörterbuch Mariano Zelke Datenstrukturen 15/26 insert(x), remove(x) und lookup(x). Binäre Suchbäume: speichern die Schlüssel in den Knoten eines Binärbaums. Wesentlich: die binäre Suchbaumordnung: alle im linken Teilbaum eines Knoten v gespeicherten Schlüssel sind kleiner als der von v gespeicherte Schlüssel ist. Alle im rechten Teilbaum von v gespeicherten Schlüssel sind größer. Mit der binären Suchbaumordnung kann ein Schlüssel schnell gefunden werden, indem die namensgebende Binärsuche durchgeführt wird. Die Dauer einer lookup-operation/remove-operation im worst-case proportional zur Tiefe. die Tiefe eines binären Suchbaums mit n Schlüsseln ist log 2 n im best-case, n 1 im worst-case und O(log 2 n) im Erwartungswert.
AVL-Bäume Mariano Zelke Datenstrukturen 16/26 Ein AVL-Baum ist ein binärer Suchbaum mit Höhenbalancierung In der Höhenbalancierung wird verlangt, dass sich, für jeden Knoten v, die Höhe des linken und rechten Teilbaums von v um höchstens eins unterscheiden. Die lookup-operation wird wie für binäre Suchbäume mit binärer Suche ausgeführt. Die remove-operation wird im Wesentlichen umgangen und durch eine lazy remove -Operation ersetzt. Links- und Rechtsrotationen sind die wesentlichen Hilfsmittel in der Ausführung der insert-operation. Während im Zick-Zick und Zack-Zack Fall nur eine Rotation pro Iteration auszuführen ist, müssen im Zick-Zack und Zack-Zick Fall zwei Rotationen ausgeführt werden. Die Ausführungszeiten von insert, remove und lookup sind für einen AVL-Baum mit n Schlüsseln durch O(log 2 n) beschränkt.
Hashing Mariano Zelke Datenstrukturen 17/26 Der Auslastungsfaktor λ = n m spielt eine wichtige Größe: n ist die Anzahl der in der Hashtabelle eingefügten Schlüssel und m ist die Größe der Hashtabelle. Hashing mit Verkettung alle Kollisionen, also alle Schlüssel x mit Hashwert h(x) = i, werden in eine sortierte Liste eingefügt. Die erwartete Länge einer Liste ist durch 1 + λ beschränkt und damit ist die erwartete Laufzeit einer insert, remove oder lookup-operation durch O(1) + λ beschränkt. Eine erfolgreiche Hashfunktion ist h(x) = x mod m. Hier sollte m eine Primzahl sein, die genügend weit von einer Zweierpotenz entfernt ist.
Hashing mit offener Addressierung Es wird direkt in die Tabelle gehasht. Benutze dazu eine Folge h 0, h 1,..., h m 1 von Hashfunktionen: Ist der ite Versuch des Einfügens von Schlüssel x an Position h i (x) nicht erfolgreich gewesen, dann wird die Position h i+1 (x) im nächsten Versuch getestet. Insbesondere verwendet man die folgende Daumenregel: Ist der Auslastungsfaktor auf 1 2 angestiegen, dann lade die Tabelle in eine neue Tabelle doppelter Größe. Im linearen Austesten verwendet man die Folge h i (x) = (x + i) mod m im doppelten Hashing benutzt man Hashfunktionen f (x) = x mod m und g(x) = m (x mod m ) und setzt h i (x) = (f (x) + i g(x)) mod m. Im linearen Austesten besteht die Gefahr der Klumpenbildung, allerdings sind die einzelnen Hashfunktionen wesentlicher schneller auswertbar als für das doppelte Hashing. Mariano Zelke Datenstrukturen 18/26
Klausur am 27. Juli, 9 Uhr, Hörsaal HV und HVI Mariano Zelke Datenstrukturen 19/26 Denken Sie an eine rechtzeitige Anmeldung. Seien Sie pünktlich zu 9:00 Uhr. Sie dürfen ein handschriftlich beidseitig beschriebenes DIN A4-Blatt als Hilfsmittel mitbringen. Sie müssen mitbringen: dokumentenechten schwarzen oder blauen Stift, einen gültigen Lichtbildausweis (z.b. Ihre Goethe-Card oder Ihren Personalausweis) Sie dürfen nicht benutzen: eigenes Schreibpapier, Skript, Taschenrechner, eingeschaltetes Handy Sitzordnung wird von uns kurz vorher bekannt gegeben.
Klausur im WS 2012/13 am 1.10., 9 Uhr in Hörsaal HV Mariano Zelke Datenstrukturen 20/26 Diese Klausur kann unabhängig von der Teilnahme an der ersten Klausur mitgeschrieben werden. Informationen dazu (Wiederholungsveranstaltungen etc.) finden Sie einige Wochen vorher auf der Homepage.
Klausurvorbereitung Mariano Zelke Datenstrukturen 21/26 Der Stoff der Vorlesung bis einschließlich 3.7. ist klausurrelevant. Wiederholen Sie die Übungsaufgaben. Schauen Sie sich die alten Klausuren hinten im Skript an. Nutzen Sie auch das Logbuch auf der Webseite für einen Überblick über die Themen. Am 17., 18., 23. und 24. Juli finden Helpdesk-Termine der Tutoren statt. Die genauen Termine und Orte finden Sie auf der Homepage. Dort finden Sie auch bald die Liste der Bonuspunkte. Prüfen Sie dann Ihren Eintrag!
C++-Code vs. Pseudocode I Mariano Zelke Datenstrukturen 22/26 Tiefensuche void tsuche(int v){ Knoten *p; besucht[v] = 1; for (p = A[v]; p!=0; p = p->next) if (!besucht [p->name]); tsuche(p->name); } Dieser C++-Code könnte als Pseudocode so geschrieben werden: tsuche(zahl v) 1 besucht[v] = true; 2 for jeden Knoten p in A[v] der Reihenfolge nach do 3 if besucht[name von p] = false then 4 tsuche(name von p);
C++-Code vs. Pseudocode II Mariano Zelke Datenstrukturen 23/26 Der schon bekannte Pseudocode für Algorithmus A 4 : (1) Max 1 = Max 1 = a 1. (2) Für k = 1,..., n 1 setze Max k+1 = max{max k + a k+1, a k+1 } und Max k+1 = max{max k, Max k+1 }. (3) Max n wird ausgegeben. Das reicht als Beschreibung des Algorithmus aus, wenn klar ist, dass die Eingabe aus n Zahlen a 1, a 2,..., a n besteht.
C++-Code vs. Pseudocode III Mariano Zelke Datenstrukturen 24/26 Der schon bekannte Pseudocode für Matrixaddition mit einfach verketteten Listen: (1) Beginne jeweils am Anfang der Listen L A und L B. (2) Solange beide Listen nicht leer sind, wiederhole (a) das gegenwärtige Listenelement von L A (bzw. L B ) habe die Koordinaten (i A, j A ) (bzw. (i B, j B )). (b) Wenn i A < i B (bzw. i A > i B ), dann füge das gegenwärtige Listenelement von L A (bzw. L B ) in die Liste L C ein und gehe zum nächsten Listenelement von L A (bzw. L B ). (c) Wenn i A = i B und j A < j B (bzw. j A > j B ), dann füge das gegenwärtige Listenelement von L A (bzw. L B ) in die Liste L C ein und gehe zum nächsten Listenelement von L A (bzw. L B ). (d) Wenn i A = i B und j A = j B, addiere die beiden Einträge und füge die Summe in die Liste L C ein. Die Zeiger in beiden Listen werden nach rechts bewegt. (3) Wenn die Liste L A (bzw. L B ) leer ist, kann der Rest der Liste L B (bzw. L A ) an die Liste L C angehängt werden. Das reicht als Beschreibung aus, wenn das Format der Eingabe klar ist.
C++-Code vs. Pseudocode IV Mariano Zelke Datenstrukturen 25/26 Der Algorithmus von Prim läuft auf einem Graphen G = (V, E) mit V = {0, 1,..., n 1}. Dafür ist der folgende Pseudocode schon bekannt: (1) Setze S = {0}. (2) Solange S V, wiederhole: (a) Bestimme eine kürzeste kreuzende Kante e = {u, v}. (b) Füge e zu B hinzu. (c) Wenn u S, dann füge v zu S hinzu. Ansonsten füge u zu S hinzu. Das reicht als Beschreibung des Algorithmus aus, vorausgesetzt, es wird klar gemacht, wie die kreuzenden Kanten verwaltet werden, so dass die kürzeste davon schnell gefunden werden kann.
C++-Code vs. Pseudocode V Mariano Zelke Datenstrukturen 26/26 Der folgende schon bekannte Pseudocode beschreibt insert(x) bei Hashing mit offener Adressierung: Wir arbeiten mit einer Folge von Hashfunktionen. Setze i = 0. h 0,..., h m 1 : U {0,..., m 1} (1) Wenn die Zelle h i (x) frei ist, dann füge x in Zelle h i (x) ein. (2) Ansonsten setze i = i + 1 und gehe zu Schritt (1). Das reicht als Beschreibung aus, wenn klar ist, dass auf einem Array mit Zellen 0, 1,..., m 1 gearbeitet wird und wie die Hashfunktionen aussehen.