Datenstrukturen. Sommersemester Herzlich willkommen!!!!!

Transkript

1 Datenstrukturen Sommersemester 2015 Herzlich willkommen!!!!! 1 / 77

2 Worum geht s? Einführung 2 / 77

3 Abstrakte Datentypen und Datenstrukturen Ein abstrakten Datentyp ist eine Sammlung von Operationen (auf einer Menge von Objekten). Implementiere den abstrakten Datentyp durch eine Datenstruktur. Ein Beispiel für häufig auftretende Operationen: das Einfügen und Entfernen von Schlüsseln nach ihrem Alter. Wenn der jüngste Schlüssel zu entfernen ist: Wähle die Datenstruktur Keller (engl. Stack ). Wenn der älteste Schlüssel zu entfernen ist: Wähle die Datenstruktur Schlange (engl. Queue ). Wenn Schlüssel Prioritäten besitzen und der Schlüssel mit höchster Priorität zu entfernen ist: Wähle die Datenstruktur Heap. Einführung Inhaltsangabe 3 / 77

4 Worum geht s? - Gegeben ist ein abstrakter Datentyp. - Entwerfe eine möglichst effiziente Datenstruktur. Welche abstrakten Datentypen? Keller: Einfügen und Entfernen des jüngsten Schlüssels. Warteschlangen: Einfügen und Entfernen des ältesten Schlüssels. Prioritätswarteschlangen: Einfügen und Entfernen des wichtigsten Schlüssels. Wörterbücher: Einfügen, Entfernen (eines beliebigen Schlüssels) und Suche. Was heißt Effizienz? Minimiere Laufzeit und Speicherplatzverbrauch der einzelnen Operationen. Stelle fest wie die Ressourcen mit wachsender Eingabelänge skalieren. Führe eine asymptotische Analyse von Laufzeit und Speicherplatzverbrauch durch. Einführung Inhaltsangabe 4 / 77

5 Worauf wird aufgebaut? (1) Diskrete Modellierung (bzw. Vorkurs): Mengen, Relationen, Worte und Tupel Vollständige Induktion und allgemeine Beweismethoden. Siehe hierzu auch die Seite des Vorkurs Informatik mit Folien zu Beweistechniken, Induktion und Rekursion wie auch Asymptotik und Laufzeitanalyse. (2) Grundlagen der Programmierung 1: Kenntnis der elementaren Datenstrukturen ist hilfreich, aber nicht notwendig. (3) Mathematik 1 (bzw. Vorkurs): - Logarithmen, - Grenzwerte und - asymptotische Notation. Einführung Vorwissen 5 / 77

6 Die Webseite der Veranstaltung Bitte konsultieren Sie die Webseite regelmäßig! Alle Vorlesungsmateralien (Skript, Folien, Zugang zu Videos wie auch Extra-Materalien) finden Sie auf dieser Seite. Auch organisatorische Details zum Übungsbetrieb und zur Notengebung werden beschrieben. Unter Aktuelles finden Sie zum Beispiel: Anmerkungen zum Übungsbetrieb (wie melde ich mich an?) und gegebenenfalls Anmerkungen zu aktuellen Übungsaufgaben. Im Logbuch finden Sie Informationen, Beamer-Folien, Videos, weitere Referenzen zu den einzelnen Vorlesungsstunden. Einführung Webseite 6 / 77

7 Literatur (1/2) - Das Skript zur Vorlesung wie auch die Beamer-Dateien können von der Webseite der Veranstaltung heruntergeladen werden. - Kapitel 3-5, und 18 in T.H. Cormen, C.E. Leiserson, R.L. Rivest und C. Stein, Introduction to Algorithms (second edition), second edition, M. T. Goodrich, R. Tamassia und D. M. Mount, Data Structures and Algorithms in C++, M. Dietzfelbinger, K. Mehlhorn und P. Sanders, Algorithmen und Datenstrukturen, die Grundwerkzeuge, Springer Vieweg, R. Sedgewick, Algorithmen in C++, (9. Auflage, Kapitel 1-7 im Grundlagenteil. - Kapitel 1-3 in J. Kleinberg und E. Tardos, Algorithm Design (GL-1 Textbuch), Pearson New International Edition, Für mathematische Grundlagen: N. Schweikardt, Diskrete Modellierung, eine Einführung in grundlegende Begriffe und Methoden der Theoretischen Informatik, (Kapitel 2,5) D. Grieser, Mathematisches Problemlösen und Beweisen, eine Entdeckungsreise in die Mathematik, Springer Vieweg Einführung Literatur 7 / 77

8 Literatur (2/2) Sämtliche Textbücher befinden sich auch in der Bibliothek im Handapparat der Veranstaltung Datenstrukturen. Die Bibliothek befindet sich im 1. Stock in der Robert-Mayer Strasse Im Logbuch werden wir für jede Veranstaltung auf relevante Literatur verweisen: Bitte schmökern! Einführung Literatur 8 / 77

9 Organisatorisches Einführung Organisatorisches 9 / 77

10 Fragestunde Im 2-Wochenrythmus, beginnend in der Woche des 27. April, wird eine Fragestunde angeboten: Fragen zu Vorlesungsinhalten, Durchrechnen von Beispielen, Kommentare, Anmerkungen zum aktuellen Übungsblatt. Mögliche Termine, jeweils im Magnus-Hörsaal (Robert-Mayer Strasse 11-15), Montags ab 17 Uhr oder Dienstags ab 16 Uhr. Einführung Organisatorisches 10 / 77

11 Klausur Die Erstklausur findet am Dienstag, dem 4. August um 9:00 im H VI statt. Die Zweitklausur findet am Montag, dem 5. Oktober ebenfalls um 9:00 im H VI statt. Die in den Übungen erreichten Punkte werden mit einem Maximalgewicht von 20% zu den Klausurpunkten hinzugezählt: Werden in der Klausur x% und in den Übungen y% erzielt, dann ist z = x + y/5 die Gesamtpunktzahl. Die Note hängt nur von der Gesamtpunktzahl z ab. Die Veranstaltung ist bestanden, wenn z 50. Einführung Organisatorisches 11 / 77

12 Übungsbetrieb Übungsblätter werden im 2-Wochen Rhythmus (in ungeraden Kalenderwochen) auf die Webseite gestellt: Wir versuchen, Übungsblätter frühzeitig ins Netz zu stellen, spätestens aber am Dienstag der Ausgabewoche. Lösungen (zusammengeheftet und mit Nummer der Übungsgruppe versehen) sind nach 2-wöchiger Bearbeitungszeit abzugeben: Entweder im HV vor Beginn der Vorlesung oder in den Briefkasten vor Büro 312, Robert-Mayer Strasse einwerfen. Für das letzte der sechs Übungsblätter gilt eine 1-wöchige Bearbeitungszeit. Übungsgruppen treffen sich schon in der ersten Woche (ab Mittwoch), um das umfangreiche Präsenzblatt in den ersten drei Wochen zu besprechen. Das erste Übungsblatt erscheint am Dienstag nächster Woche. Übungsaufgaben können mit Anderen besprochen werden, Lösungen müssen aber eigenständig aufgeschrieben werden! Ein erstmaliger Verstoß führt für ALLE Beteiligten zur Nicht-Anrechnung aller Punkte des Blatts. Bei einem zweiten Verstoß werden ALLE Übungspunkte gestrichen. Einführung Organisatorisches 12 / 77

13 BITTE, BITTE, BITTE... UNBEDINGT am Übungsbetrieb teilnehmen und Aufgaben bearbeiten! Anmeldung über die Webseite! Die Wahrscheinlichkeit zu bestehen ist fast 100%, wenn mindestens 50% der Übungspunkte erreicht werden. Einführung Organisatorisches 13 / 77

14 BITTE, BITTE, BITTE... Helfen Sie uns durch ihre Fragen, Kommentare und Antworten! Die Veranstaltung kann nur durch Interaktion interessant werden. Meine Sprechstunde: Dienstags Oder versuchen Sie es einfach aufs Geratewohl (Raum 302 oder Raum 303 oder 313). Einführung Organisatorisches 14 / 77

15 Weitere Links und nützliche Informationen Im treffen Sie ihre KommilitonInnen. Ingo-Wegener Lernzentrum Frau Düffel hilft mit Rat in allen Lebenslagen und nicht nur in Fragestellungen der Datenstrukturen. Die Seite enthält Informationen nur für Erstsemester. Einführung Organisatorisches 15 / 77

16 Mathematische Grundlagen Mathematische Grundlagen 16 / 77

17 Vollständige Induktion Das Ziel: Zeige die Aussage A(n) für alle natürlichen Zahlen n n 0. Die Methode der vollständigen Induktion 1. Zeige im INDUKTIONSANFANG die Aussage A(n 0 ) und 2. im INDUKTIONSSCHRITT die Implikation (A(n 0 ) A(n 0 + 1) A(n)) A(n + 1) für jede Zahl n mit n n 0. A(n 0 ) A(n 0 + 1) A(n) heißt Induktionsannahme. Häufig nimmt man nur die Aussage A(n) in der Induktionsannahme an. Beachte aber das folgende Beispiel der Fibonacci-Zahlen. Mathematische Grundlagen Vollständige Induktion 17 / 77

18 Karnickel (1/3) Ein Bauer züchtet Kaninchen. Jedes weibliche Kaninchen bringt im Alter von zwei Monaten ein weibliches Kaninchen zur Welt und danach jeden Monat ein weiteres. Wie groß ist die Anzahl fib(n) der weiblichen Kaninchen am Ende des n-ten Monats, wenn der Bauer mit einem neu geborenen weiblichen Kaninchen im ersten Monat startet? Antwort: fib(n) ist rekursiv wie folgt definiert: Rekursionsanfang: fib(1) := 1 und fib(2) := 1, Rekursionsschritt: fib(n + 1) := fib(n) + fib(n 1) für alle n N mit n 2. Die Funktion fib wird auch Fibonacci-Folge a genannt, die Zahl fib(n) heißt auch n-te Fibonacci-Zahl. a Zu Ehren von Leonardo Fibonacci (13. Jh.), einem italienischen Mathematiker Mathematische Grundlagen Vollständige Induktion 18 / 77

19 Karnickel (2/3) Zur Erinnerung: Es ist Somit gilt: fib(1) := 1 und fib(2) := 1 und fib(n + 1) := fib(n) + fib(n 1) f.a. n N mit n 2. n fib(n) Wie stark wächst die Folge fib(n)? Zeige, fib(n) 2 n mit der erweiterten Induktionsannahme und n 0 = 1. Zeige 2 n/2 fib(n) gilt für n 6 mit der erweiterten Induktionsannahme und n 0 = 6. Mathematische Grundlagen Vollständige Induktion 19 / 77

20 Karnickel (3/3) Es gibt auch einen expliziten Ausdruck für die n-te Fibonacci-Zahl. F.a. n N >0 gilt nämlich: ( ( fib(n) = 1 ) n ( ) n ) Man zeigt die Bemerkung durch vollständige Induktion nach n. Die zentrale Beobachtung: Sowohl wie auch erfüllen die quadratische Gleichung x 2 = x + 1. Mathematische Grundlagen Vollständige Induktion 20 / 77

21 Analyse rekursiver Programme Mathematische Grundlagen Rekursionsbäume 21 / 77

22 Rekursive Programme und ihre Rekursionsbäume Sei x eine Eingabe für ein rekursives Programm R( p) (mit den Parametern p). Wir führen einen Rekursionsbaum nach den folgenden Regeln ein. 1. Beschrifte die Wurzel von B mit den Parametern p des Erstaufrufs. Wenn innerhalb von R( p) keine rekursiven Aufrufe getätigt werden, dann wird die Wurzel zu einem Blatt. Sonst erhält die Wurzel für jeden rekursiven Aufruf innerhalb von R( p) ein neues Kind, das mit den Parametern des rekursiven Aufrufs beschriftet wird. 2. Wenn ein Knoten v von B mit den Parametern q beschriftet ist, gehen wir mit v genauso wie mit der Wurzel um. Wenn in R( q) keine rekursiven Aufrufe getätigt werden, dann wird v zu einem Blatt. Ansonsten erhält v für jeden rekursiven Aufruf in R( q) ein neues Kind, das mit den Parametern des rekursiven Aufrufs beschriftet wird. Was erzählt uns der Rekursionsbaum? Z. B. stimmt die Anzahl der Knoten von B mit der Anzahl aller rekursiven Aufrufe für Eingabe x (und Parameter p) überein. Mathematische Grundlagen Rekursionsbäume 22 / 77

23 Eine Berechnung der Fibonacci-Zahlen auf die grausame Art Mathematische Grundlagen Rekursionsbäume 23 / 77

24 Eine rekursive Berechnung der Fibonacci-Zahlen Algo(n): 1. Falls n = 1, dann return Algo(1) := Falls n = 2, dann return Algo(2) := Falls n 3, dann return Algo(n) := Algo(n 1) + Algo(n 2). Zähle jede Addition, jeden Vergleich, und jede Ergebnis-Rückgabe als einen Schritt. Für die Anzahl g(n) benötigter Schritte gilt: g(1) = 2, g(2) = 3 und g(n) = 3 + g(n 1) + g(n 2) + 2 = 5 + g(n 1) + g(n 2) Um Himmels willen, für n 6 ist g(n) fib(n) 2 n/2, die Laufzeit ist exponentiell Das geht doch viel, viel schneller, oder!?! Mathematische Grundlagen Rekursionsbäume 24 / 77

25 Der Rekursionsbaum (1/2) Die Rekursionsbäume B n für Algo(n) sind rekursiv definiert: - Rekursionsanfang: Die Bäume B 1 und B 2 bestehen nur aus einem einzigen Knoten der jeweils mit 1, bzw. 2 markiert ist. - Rekursionsschritt: Die Wurzel r von B n ist mit n markiert, die Wurzel von B n 2 ist linkes Kind von r und die Wurzel von B n 1 rechtes Kind von r. n n 2 n 1 B n 2 n 3 n 2 B n 3 B n 2 Abbildung: Die rekursive Definition des Baums B n Mathematische Grundlagen Rekursionsbäume 25 / 77

26 Der Rekursionsbaum (2/2) Abbildung: Die Fibonacci-Bäume B 1, B 2, B 3, B 4, B 5 und B Die Wurzel von B n berechnet die nte Fibonacci-Zahl. 2. Die Fibonacci-Zahl fib(4) wird 2-mal in B 6 berechnet, fib(3) wird 3-mal berechnet. WARUM? Und wie berechnet man B n pfeilschnell? Mathematische Grundlagen Rekursionsbäume 26 / 77

27 Binärsuche Mathematische Grundlagen Rekursionsbäume 27 / 77

28 Binärsuche Ein Array A = (A[1],..., A[n]) von n Zahlen und eine Zahl x ist gegeben: Wir möchten wissen, ob und wenn ja wo die Zahl x in A vorkommt. Wenn A nicht sortiert ist, dann wird die lineare Suche bis zu n Zellen des Arrays inspizieren. Wenn das Array aber aufsteigend sortiert ist, dann können wir Binärsuche anwenden. Mathematische Grundlagen Rekursionsbäume 28 / 77

29 Binärsuche: Das Programm void Binärsuche( int unten, int oben){ if (oben < unten) std::cout «x «wurde nicht gefunden. «std::endl; int mitte = (unten+oben)/2; if (A[mitte] == x) std::cout «x «wurde in Position «mitte «gefunden. «std::endl; else { if (x < A[mitte]) Binärsuche(unten, mitte-1); else Binärsuche(mitte+1,oben);}} Wir sagen, dass Zelle im ersten Aufruf inspiziert wird. A[mitte] Mathematische Grundlagen Rekursionsbäume 29 / 77

30 Binärsuche: Korrektheit Wir zeigen durch vollständige Induktion nach n = oben unten + 1, dass Binärsuche(unten,oben) korrekt ist. (a) INDUKTIONSANFANG für n = 0: Es ist n = oben unten + 1 = 0 oben < unten. Binärsuche(unten, oben) bricht mit der Antwort x wurde nicht gefunden ab. (b) INDUKTIONSSCHRITT n n + 1: Es ist oben unten + 1 = n + 1. Wenn A(mitte) = x, dann wird mit Erfolgsmeldung abgebrochen. Ansonsten, wenn x < A[mitte], sucht Binärsuche richtigerweise in der linken Hälfte und sonst in der rechten Hälfte. Die rekursive Suche in der linken bzw. rechten Hälfte verläuft aber nach Induktionsannahme korrekt. Mathematische Grundlagen Rekursionsbäume 30 / 77

31 Binärsuche: Die Laufzeit Wie groß ist T (n) := maximale Anzahl inspizierter Zellen für ein Array mit n Zellen, für n = 2 k 1? Hier ist eine rekursive Definition von T (n): - Rekursionsanfang: T (0) := 0. - Rekursionsschritt: T (n) := T ( n 1 2 ) Wir haben n = 2 k 1 gefordert. Beachte, dass n 1 2 = 2k 2 2 = 2 k 1 1 gilt. 2. Wir zeigen T (2 k 1) = k mit vollständiger Induktion nach k. (a) INDUKTIONSANFANG: T (2 0 1) = T (0) = 0. (b) INDUKTIONSSCHRITT: T (2 k+1 1) = T (2 k 1) + 1 Induktionsannahme = k + 1. Binärsuche muss höchstens k Zahlen inspizieren gegenüber 2 k 1 Zahlen für die lineare Suche: Die lineare Suche ist exponentiell langsamer als Binärsuche. Mathematische Grundlagen Rekursionsbäume 31 / 77

32 Binärsuche: Der Rekursionsbaum Wie sieht der Rekursionsbaum B für ein Array A und einen Schlüssel y aus, der nicht in A vorkommt? 1. Der Rekursionsbaum B besitzt den Aus-Grad Eins: Ein Knoten von B ist entweder ein Blatt oder verursacht genau einen rekursiven Aufruf. 2. Das Array A besitze genau n = 2 k 1 Schlüssel. Wir wissen: Im schlimmsten Fall werden genau k Zellen inspiziert. y kommt nicht in A vor: Der schlimmste Fall tritt ein. In jedem rekursiven Aufruf wird nur eine Zelle des Arrays inspiziert: Der Rekursionsbaum B ist also ein Weg der Länge k. Binärsuche ist schnell, weil stets höchstens ein rekursiver Aufruf getätigt wird und weil die Länge des Array-Abschnitts in dem gesucht wird, mindestens halbiert wird. Mathematische Grundlagen Rekursionsbäume 32 / 77

33 Türme von Hanoi Mathematische Grundlagen Rekursionsbäume 33 / 77

34 Die Türme von Hanoi: Die Spielregeln Die Anfangskonfiguration: Wir haben drei Stäbe 1, 2 und 3. Ursprünglich besitzt Stab 1 N Ringe, wobei die Ringe in absteigender Größe auf dem Stab aufgereiht sind: Der größte Ring von Stab 1 ist also der unterste Ring. Die Stäbe 2 und 3 sind zu Anfang leer. Die Züge Bewege einen zuoberst liegenden Ring von einem Stab zu einem anderen. Der Zug ist nur dann erlaubt, wenn der Ring auf einen größeren Ring gelegt wird oder wenn der Stab leer ist. Die Zielkonfiguration: Alle Ringe müssen nach Stab 2 bewegt werden. Stab 1 Stab 2 Stab 3 Stab 1 Stab 2 Stab 3 Mathematische Grundlagen Rekursionsbäume 34 / 77

35 Ein rekursives Programm void Hanoi( int N, int stab1, int stab2, int stab3) // Annahmen: (stab1,stab2,stab3) ist eine Permutation. Die obersten // N Ringe auf Stab stab1 passen auf stab2 und stab3. {if (N==1) else { bewege einen Ring von Stab stab1 nach Stab stab2; Hanoi(N-1,stab1,stab3,stab2); bewege einen Ring von Stab stab1 nach Stab stab2; Hanoi(N-1,stab3,stab2,stab1); }} Wie viele Ringe werden bewegt? Mathematische Grundlagen Rekursionsbäume 35 / 77

36 Das Präsenzblatt: Die Themen (a) Warum ist es gut, den Logarithmus zum Freund zu haben? (b) Viele Beispiele zur rekursiven Programmierung und zur vollständigen Induktion. (c) Worum geht es bei der Laufzeitmessung? Aber was ist das überhaupt? In den Übungen: In dieser Woche werden die Aufgaben 3,4 und 5, in der nächsten Woche die Aufgaben 6 und 7 behandelt. Mathematische Grundlagen Rekursionsbäume 36 / 77

37 Unser Freund, der Logarithmus Mathematische Grundlagen Rechnen mit Logarithmen 37 / 77

38 Rechnen mit Logarithmen Seien a > 1 und x > 0 reelle Zahlen. log a (x) ist der Logarithmus von x zur Basis a und stimmt mit z genau dann überein, wenn Insbesondere ist a log a (x) = x. (a) log a (x y) = log a x + log a y. (b) log a (x y ) = y log a (x). a z = x. (c) log a x = (log a b) (log b x). Wir übersetzen von Basis a in Basis b. Was ist 4 log 2 n? log 2 n = (log 2 4) (log 4 n) mit (c). 4 log 2 n = 4 (log 2 4) (log 4 n) = (4 log 4 n ) log 2 4 = n 2. Was ist b log a x? log a x = (log a b) (log b x) mit (c). b log a x = b (log a b) (log b x) = (b log b x ) log a b = x log a b. Mathematische Grundlagen Rechnen mit Logarithmen 38 / 77

39 Laufzeitmessung Kapitel 2: Laufzeitmessung 39 / 77

40 Eingabelänge Wie gut skaliert ein Programm, d.h. wie stark nimmt die Laufzeit zu, wenn die Eingabelänge vergrößert wird? Frage: Was ist denn überhaupt die Länge einer Eingabe? Antwort: Definiere Eingabelänge abhängig von der Problemstellung. Zum Beispiel: (a) Wenn ein Array mit n Schlüsseln zu sortieren ist, dann ist die Anzahl n der Schlüssel ein vernünftiges Maß für die Eingabelänge. (b) Wenn ein algorithmisches Problem für einen Graphen mit Knotenmenge V und Kantenmenge E zu lösen ist, dann ist die Summe der Knoten- und Kantenzahl sinnvoll. V + E Kapitel 2: Laufzeitmessung Eingabelänge 40 / 77

41 Die worst-case Laufzeit Sei P ein Programm. Für jede Eingabelänge n setze Zeit P (n) = größte Laufzeit von P auf einer Eingabe der Länge n. Wenn also die Funktion Länge : Menge aller möglichen Eingaben N einer Eingabe x die Eingabelänge Länge(x) zuweist, dann ist Zeit P (n) = max{ Anzahl der Schritte von Programm P für Eingabe x : Länge(x) = n } die worst-case Laufzeit von P für Eingaben der Länge n. Kapitel 2: Laufzeitmessung Worst-Case Laufzeit 41 / 77

42 Laufzeitmessung Für welchen Rechner sollen wir die Laufzeit berechnen? Analysiere die Laufzeit auf einem abstrakten Rechner: Der Speicher besteht aus Registern, die eine ganze Zahl speichern können. Eine CPU führt einfache boolesche und arithmetische Operationen aus. Daten werden zwischen CPU und Speicher durch (indirekte) Lade- und Speicherbefehle ausgetauscht. Damit ist die Laufzeitberechnung für jeden modernen sequentiellen Rechner gültig, aber wir erhalten für einen speziellen Rechner nur eine exakte Schätzung. bis auf einen konstanten Faktor Kapitel 2: Laufzeitmessung Asymptotik 42 / 77

43 Laufzeitmessung für welche Programmiersprache und welchen Compiler? Wir sollten mit einer Assemblersprache arbeiten: Wir sind vom Compiler unabhängig und die Anzahl der Anweisungen ist relativ klein. Aber die Programmierung ist viel zu umständlich und wir wählen deshalb C++ bzw. Pseudocode. Die Anzahl ausgeführter C++ Befehle ist nur eine Schätzung der tatsächlichen Anzahl ausgeführter Assembler Anweisungen. Unsere Schätzung ist auch hier nur bis auf einen konstanten Faktor exakt. Kapitel 2: Laufzeitmessung Asymptotik 43 / 77

44 Pseudocode 1 Was ist ein Algorithmus? Eine präzise definierte Rechenvorschrift, formuliert in Pseudocode. 2 Und was ist Pseudocode? Eine Mischung von Umgangssprache, Programmiersprache und mathematischer Notation. Typischerweise ist der Pseudocode kompakter, aber gleichzeitig auch leichter zu verstehen als der entsprechende Code einer Programmiersprache. Pseudocode folgt keinen klaren Regeln, aber natürlich muss eine nachfolgende Implementierung trivial sein! Das Präsenzblatt beschäftigt sich ausgiebig mit Pseudocode! Kapitel 2: Laufzeitmessung Asymptotik 44 / 77

45 Laufzeitmessung und Asymptotik Wie skaliert die Laufzeit unter wachsender Eingabelänge? Wir betrachten die worst-case Laufzeit in Abhängigkeit von der Eingabelänge. Unsere Laufzeitbestimmung ist letztlich nur eine, bis auf einen konstanten Faktor exakte Schätzung. Wir interessieren uns vor allen Dingen für die Laufzeit großer Eingaben und unterschlagen konstante Faktoren. Wir erhalten eine von der jeweiligen Rechnerumgebung unabhängige Laufzeitanalyse, die das Wachstumverhalten der tatsächlichen Laufzeit verläßlich voraussagt. Kapitel 2: Laufzeitmessung Asymptotik 45 / 77

46 Die asymptotische Notation Kapitel 2: Laufzeitmessung Asymptotische Notation 46 / 77

47 Wie schnell dominiert die Asymptotik? Annahme: Ein einfacher Befehl benötigt 10 9 Sekunden. n n 2 n 3 n 10 2 n n! }{{} }{{} }{{} mehr als mehr als mehr als Jahre Jahre 600 Jahre illion }{{} }{{} mehr als mehr als 15 Minuten 10 Jahre Kapitel 2: Laufzeitmessung Asymptotische Notation 47 / 77

48 Die asymptotische Notation 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. f (n) Die Klein-Oh Notation: f = o(g) lim = 0: f wächst langsamer als g. n g(n) Kapitel 2: Laufzeitmessung Asymptotische Notation 48 / 77

49 Grenzwerte und die Asymptotik Kapitel 2: Laufzeitmessung Asymptotische Notation 49 / 77

50 Grenzwerte Grenzwerte sollten das Wachstum vorausssagen! Der Grenzwert der Folge f (n) f (n) existiere und es sei lim = c. g(n) n g(n) Wenn c = 0, dann ist f = o(g). (f wächst langsamer als g.) Wenn 0 < c <, dann ist f = Θ(g). (f und g wachsen gleich schnell.) Wenn 0 c <, dann ist f = O(g). (f wächst höchstens so schnell wie g.) Kapitel 2: Laufzeitmessung Grenzwerte und die Asymptotik 50 / 77

51 Wachstum des Logarithmus (1/2) Für alle reelle Zahlen a > 1 und b > 1 gilt log a n = Θ(log b n). Warum? Es gilt Also folgt log a (n) = (log b (a)) log b (n). log lim a n n log b n = lim log n b (a). Aber a, b > 1 und deshalb 0 < log b (a) <. Die Behauptung log a n = Θ(log b n) folgt. log a (n) und der natürliche Logarithmus ln(n) haben dasselbe Wachstum: Ab jetzt arbeiten wir nur mit ln(n). Kapitel 2: Laufzeitmessung Grenzwerte und die Asymptotik 51 / 77

52 Rechnen mit Grenzwerten f, g : N R 0 seien Funktionen. Die Operation bezeichne eine der Operationen +, oder. Dann gilt lim (f (n) g(n)) = lim n f (n) lim g(n), n n falls die beiden Grenzwerte auf der rechten Seite existieren und endlich sind. Und f (n) lim f (n) lim n g(n) = n lim g(n), n gilt, falls die beiden Grenzwerte auf der rechten Seite existieren, endlich sind und lim n g(n) 0 gilt. n lim 3 +n (n+1)/2 n = lim 3 n (n+1)/2 + lim = 1. n n 3 n n 3 n n 3 Also ist n 3 + n (n+1) 2 = Θ(n 3 ) und n 3 + n (n+1) 2 ist kubisch. Kapitel 2: Laufzeitmessung Grenzwerte und die Asymptotik 52 / 77

53 Die Regel von de l Hospital f (n) lim n lim n g(n) = lim n f (n) = lim n f (n), falls der letzte Grenzwert existiert und falls g (n) g(n) {0, }. ln lim ln(n) = lim n = und lim (n) 1/n = lim = 0. n n n n n 1 ln(n) lim = 0 und damit log n n a (n) = o(n) für jedes a > 1. Der Logarithmus wächst langsamer als jede noch so kleine Potenz n b (für 0 < b): Siehe Tafel. Kapitel 2: Laufzeitmessung Die Regel von de l Hospital 53 / 77

54 Unbeschränkt wachsende Funktionen Die Funktionen f : N R und g : R R seien gegeben. (a) f sei monoton wachsend. Dann gibt es eine Konstante K N mit f (n) K oder aber lim n f (n) = gilt. Insbesondere ist f = O(1) oder 1 = o(f). (b) Für jedes a > 1 ist 1 = o(log a (n)). (c) Wenn lim n f (n) = lim n g(n) =, dann gilt lim n g(f (n)) =. (d) Wenn g = o(n) und 1 = o(f ), dann ist g(f (n)) lim = 0, n f (n) also ist g(f (n)) = o(f (n)). Wenn g sublinear ist und f unbeschränkt wächst, dann nimmt das Wachstum von g f ab. Anwendungen: (Siehe Tafel.) 1 = o(log 2 log 2 (n)). log 2 log 2 (n) = o(log 2 (n)). 1 = o(log (k+1) 2 (n)) und log (k+1) 2 (n) = o(log (k) 2 (n)) für jede natürliche Zahl k. Kapitel 2: Laufzeitmessung Die Regel von de l Hospital 54 / 77

55 Eine Wachstums-Hierarchie f 1 (n) = 1, dann ist f 1 = o(log 2 log 2 n), haben wir schon eingesehen. log 2 log 2 n = o(log 2 n), haben wir schon eingesehen. log 2 n = Θ(log a n) für jedes a > 1, haben wir schon eingesehen. log 2 n = o(n b ) für jedes b > 0, haben wir schon eingesehen. n b = o(n) und n = o(n log a n) für jedes b mit 0 < b < 1 und jedes a > 1, lim n n b n = limn 1 n 1 b = 0 und lim n n n log a n = limn 1 log a n = 0. n log a n = o(n k ) für jede reelle Zahl k > 1 und jedes a > 1. n k = o(a n ) für jedes a > 1, n k = a k log a n n und lim k n = lim a n n a k log a n n = 0. und a n = o(n!) für jedes a > 1. (Siehe Tafel) Kapitel 2: Laufzeitmessung Eine Wachstums-Hierarchie 55 / 77

56 Was ist gut, was ist schlecht? 1. Die konstante Funktion wächst am langsamsten, gefolgt von log (k) a (n). 2. Selbst für sehr, sehr kleine Potenzen 0 < b < 1 wächst der Logarithmus viel, viel langsamer als n b. Häufig auftretende Anfragen an eine Datenstruktur sollten in Zeit O(log2 n) und besser noch in Zeit O(1) laufen. 3. Dann kommen f (n) = n und g(n) = n log 2 n. Jedes Programm, dass sich alle n Eingabedaten anschauen muss, muss mindestens Ω(n) Schritte investieren. Die Laufzeitfunktion n log2 n taucht für schnelle Divide & Conquer Algorithmen auf. 4. Laufzeiten n k für k > 1 sind teuer. (Schon quadratische Laufzeiten tun weh). 5. Die Laufzeiten h(n) = a n sind unbezahlbar und für h (n) = n! mehr als unverschämt: Die Funktionen a n und n! sind Stars in jedem Gruselkabinett und selbst kubische Laufzeiten lassen einen kalten Schauer über den Rücken laufen. Kapitel 2: Laufzeitmessung Eine Wachstums-Hierarchie 56 / 77

57 Laufzeitanalyse von C++ Programmen und Pseudocode: Zähle Anweisungen, die die Laufzeit dominieren Kapitel 2: Laufzeitmessung Laufzeitanalyse 57 / 77

58 Analyse von C++ Programmen Bestimme und zähle dominierende Anweisungen. Die Anzahl ausgeführter dominierender Anweisungen sollte einfach zu bestimmen sein und die asymptotische Anzahl aller ausgeführten Anweisungen nicht verfälschen. Zum Beispiel: Zähle die Anzahl bestimmter ausgeführter elementarer Anweisungen wie etwa Zuweisungen und Auswahl-Anweisungen (if-else und switch). Zähle weder iterative Anweisungen (for, while und do-while), noch Sprunganweisungen (break, continue, goto und return) oder Funktionsaufrufe. Ist der so ermittelte Aufwand denn nicht zu klein? Zähle mindestens eine ausgeführte elementare Anweisung in jedem Schleifendurchlauf oder Funktionsaufruf. In den meisten Fällen sind wir an der worst-case Laufzeit interessiert: Bestimme für jede Eingabelänge n die maximale Laufzeit für eine Eingabe der Länge n. Kapitel 2: Laufzeitmessung Laufzeitanalyse 58 / 77

59 Zuweisungen, Auswahl-Anweisungen und Schleifen 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. Die Auswertung der Bedingung in einer Auswahl-Anweisungen ist nicht notwendigerweise zu zählen. Aber die Laufzeit hängt jetzt vom Wert der Bedingung ab! Häufig genügt die Bestimmung des Gesamtaufwands für den längsten der alternativen Anweisungsblöcke. Schleifen: Der Aufwand kann in jedem Schleifendurchlauf variieren! Häufig genügt die Bestimmung der maximalen Anzahl ausführbarer Anweisungen innerhalb einer Schleife sowie die Anzahl der Schleifendurchläufe. Kapitel 2: Laufzeitmessung Laufzeitanalyse 59 / 77

60 Beispiel: For-Schleifen Die Matrizenmultiplikation A B = C: for (i=0; i < n; i++) for (j=0; j < n; j++) {C[i][j] = 0; for (k=0; k < n ; k++) C[i][j] += A[i][k]*B[k][j]; } Zähle die Anzahl der Zuweisungen. Analysiere die geschachtelten for-schleifen durch geschachtelte Summen: Laufzeit = n 1 i=0 n 1 j=0 n 1 (1 + k=0 n 1 n 1 1) = (1 + n) = n 2 (1 + n). i=0 j=0 Das Programm besitzt kubische Laufzeit. Kapitel 2: Laufzeitmessung Laufzeitanalyse 60 / 77

61 Beispiel: While Schleifen (1/2) while (n >= 1) {n = n/2; Eine Menge von maximal c Anweisungen, die n nicht verändern } Zähle die höchstens 1 + c Anweisungen pro Schleifendurchlauf. T (n) bezeichne die Laufzeit der while-schleife für Parameter n. Wir erhalten die Rekursionsgleichung:T (1) 1 + c, T (n) T (n/2) c. Die Laufzeit ist logarithmisch. Warum? Höchstens 1 + c Anweisungen pro Schleifendurchlauf. Und wieviele Iterationen? Na klar, 1 + log2 n viele. Kapitel 2: Laufzeitmessung Laufzeitanalyse 61 / 77

62 Beispiel: While Schleifen (2/2) while (n > 1) n = ( n & 1 )? 3*n + 1 : n/2; Was tut diese while Schleife? Wenn n ungerade ist, dann ersetze n durch 3 n + 1. Wenn n gerade ist, dann ersetze n durch n. 2 Was ist die asymptotische Laufzeit in Abhängigkeit von der Eingabelänge n? Es ist bis heute nicht bekannt, ob die Schleife für jede Eingabe terminiert! Die Laufzeit ist deshalb erst recht nicht bekannt. Die Analyse der Laufzeit kann äußerst schwierig sein! Kapitel 2: Laufzeitmessung Laufzeitanalyse 62 / 77

63 Algorithmenentwurf, Laufzeitmessung, und asymptotische Analyse. Wie passt das alles zusammen? Kapitel 2: Laufzeitmessung Laufzeitanalyse 63 / 77

64 Ein Beispiel: Das Teilfolgenproblem Die Eingabe besteht aus n ganzen Zahlen a 1,..., a n. Definiere f (i, j) = a i + a i a j für 1 i j n. Das Ziel ist die Berechnung von max{f (i, j) 1 i j n}, also die maximale Teilfolgensumme. Anwendungbeispiel für Aktien: Berechne den größten Gewinn für ein Zeitintervall. Kapitel 2: Laufzeitmessung Laufzeitanalyse 64 / 77

65 Algorithmen für das Teilfolgenproblem Wir betrachten nur Algorithmen A, die ausschließlich auf den Daten ausführen. Additionen und/oder Vergleichsoperationen Additionen A (n) = max a1,...a n Z{ Anzahl Additionen von A für Eingabe (a 1,..., a n)} Vergleiche A (n) = max a1,...,a n Z{ Anzahl Vergleiche von A für Eingabe (a 1,..., a n)}. Zeit A (n) = Additionen A (n) + Vergleiche A (n) ist die worst-case Rechenzeit von Algorithmus A. Kapitel 2: Laufzeitmessung Laufzeitanalyse 65 / 77

66 Das Teilfolgenproblem: Algorithmus A 1 Max = ; for (i=1 ; i <= n; i++) for (j=i ; j <= n; j++) {Berechne f (i, j) mit j i Additionen; Max = max{f (i, j), Max}; } Wir benötigen j i Additionen zur Berechnung von f (i, j). Also ist n n Additionen A1 (n) = (j i). Eine obere Schranke: Additionen A1 (n) n i=1 n j=1 n = n3. Eine untere Schranke: Additionen A1 (n) n/4 n n i=1 j=3n/4+1 und 2 Additionen A1 (n) n n n = n3 folgt i=1 j=i Die Laufzeit von A 1 ist kubisch: Die Laufzeit nimmt um den Faktor acht zu, wenn sich die Eingabelänge verdoppelt. :-(( Kapitel 2: Laufzeitmessung Laufzeitanalyse 66 / 77

67 Das Teilfolgenproblem: Algorithmus A 2 Max = ; for (i=1 ; i <= n; i++) { f (i, i 1) = 0; for (j=i ; j <= n; j++) { f (i, j) = f (i, j 1) + a j ; Max = max{f (i, j), Max}; }} Wir benötigen genau so viele Additionen wie Vergleiche. Also ist Zeit A2 (n) = Additionen A2 (n) + Vergleiche A2 (n) = n (n + 1) 2 + n (n + 1) 2 lim n n (n+1) n 2 = 1 und deshalb folgt Zeit A2 (n) = Θ(n 2 ). = n (n + 1). Die Laufzeit von A 2 ist quadratisch und wächst damit um den Faktor vier, wenn sich die Eingabelänge verdoppelt :-(( Kapitel 2: Laufzeitmessung Laufzeitanalyse 67 / 77

68 Zwischenfazit Mit Hilfe der asymptotischen Notation können wir sagen, dass A1 eine kubische Laufzeit und A2 eine quadratische Laufzeit besitzt. n Es ist lim 2 n = 0 und damit folgt n 2 = o(n 3 ): n 3 A 2 ist wesentlich schneller als A 1. Aber es geht noch deutlich schneller! Kapitel 2: Laufzeitmessung Laufzeitanalyse 68 / 77

69 Ein Divide & Conquer Ansatz Angenommen, wir kennen den maximalen f (i, j) Wert opt links für 1 i j n 2 sowie den maximalen f (i, j)-wert opt rechts für n + 1 i j n. 2 Welche Möglichkeiten gibt es für den maximalen f (i, j)-wert opt für 1 i j n? 1. opt = opt links und die maximale Teilfolge liegt in linken Hälfte. 2. opt = opt rechts und die maximale Teilfolge liegt in rechten Hälfte. 3. opt = max{f (i, j) 1 i n, n + 1 j n}: 2 2 eine maximale Teilfolge beginnt in der linken und endet in der rechten Hälfte. Kapitel 2: Laufzeitmessung Laufzeitanalyse 69 / 77

70 Das Teilfolgenproblem: Algorithmus A 3 A 3 (i, j) bestimmt den Wert einer maximalen Teilfolge für a i..., a j. (1) Wenn i = j, dann gib a i als Antwort aus. (2) Ansonsten setzte mitte = i+j 2 ; (3) opt 1 = max{f (k, mitte) i k mitte }; opt 2 = max{f (mitte + 1, l) mitte + 1 l j}; (4) opt = max{ A 3 (i, mitte), A 3 (mitte + 1, j), opt 1 + opt 2 } wird als Antwort ausgegeben. n = j i + 1 ist die Eingabelänge. n sei eine Zweierpotenz. Wie bestimmt man die Laufzeit Zeit A3 (n)? ZeitA3 (1) = 1, In Schritt (4) werden zwei rekursive Aufrufe für Eingabelänge n mit Laufzeit 2 jeweils Zeit A3 ( n ) ausgeführt. Dazu kommen t(n) weitere nicht-rekursive 2 Operationen aus (3) und (4). Also Zeit A3 (n) = 2 Zeit A3 ( n 2 ) + t(n). Kapitel 2: Laufzeitmessung Laufzeitanalyse 70 / 77

71 Wie löst man Rekursionsgleichungen? Wie groß ist der Overhead t(n)? Um opt1 und opt 2 zu berechnen genügen n 1 + n 1 = n 2 Additionen. 2 2 Dieselbe Anzahl von Vergleichen wird benötigt. Eine weitere Addition wird für opt1 + opt 2 benötigt, zwei weitere Vergleiche fallen in Schritt (4) an. t(n) = 2 (n 2) + 3 = 2n + 1. Wir erhalten die Rekursionsgleichnungen: Zeit A3 (1) = 1 Zeit A3 (n) = 2 Zeit A3 ( n 2 ) + 2n 1. Der allgemeinere Fall: Ein rekursives Programm A mit Eingabelänge n besitze a rekursive Aufrufe mit Eingabelänge n und es werden t(n) nicht-rekursive Operationen ausgeführt. b Die Rekursionsgleichung: Zeit A (n) = a Zeit A ( n b ) + t(n). Kapitel 2: Laufzeitmessung Rekursionsgleichungen 71 / 77

72 Das Mastertheorem Kapitel 2: Laufzeitmessung Das Mastertheorem 72 / 77

73 Der Baum der Rekursionsgleichung (1/2) Die Rekursionsgleichung T (1) = c, T (n) = a T ( n b ) + t(n) ist zu lösen. n sei eine Potenz der Zahl b > 1 und a 1, c > 0 gelte. Der Baum der Rekursionsgleichung: 1. Wir sagen, dass die Wurzel root die Eingabelänge n hat. Wenn n = 1, dann markiere root mit c und root wird zu einem Blatt. Wenn n > 1, dann markiere root mit t(n). root erhält a Kinder mit Eingabelänge n/b. 2. Sei v ein Knoten des Baums mit Eingabelänge m. Wenn m = 1, dann markiere v mit c und v wird zu einem Blatt. Wenn m > 1, dann markiere v mit t(m) und v erhält a Kinder mit Eingabelänge m/b. T (n) stimmt überein mit der Summe aller Knotenmarkierungen Wende vollständige Induktion an. Kapitel 2: Laufzeitmessung Das Mastertheorem 73 / 77

74 Der Baum der Rekursionsgleichung (2/2) Die Rekursionsgleichung T (1) = c, T (n) = a T ( n b ) + t(n) ist zu lösen. n sei eine Potenz der Zahl b > 1 und a 1, c > 0 gelte. Die Tiefe eines Knotens v ist die Länge des Weges von der Wurzel zu v. (a) Mit vollständiger Induktion: Der Baum hat in Tiefe d genau a d Knoten. (b) Die Tiefe des Baums ist log b n. Die Anzahl seiner Blätter ist Das Mastertheorem: Sei ε > 0. a log b n = a (log b a) (log a n) = a (log a n) (log b a) = n log b a. 1. Wenn t(n) = O(n (log b a) ɛ ), dann ist T (n) = Θ(n log b a ): Die Anzahl der Blätter dominiert in T (n). 2. Wenn t(n) = Θ(n log b a ), dann T (n) = Θ(n log b a log b n): Gleichgewicht zwischen den log b n Schichten des Baums. 3. Wenn t(n) = Ω(n (log b a)+ε ), dann T (n) = Θ(t(n)): Die Wurzel dominiert. Kapitel 2: Laufzeitmessung Das Mastertheorem 74 / 77

75 Das Mastertheorem: Die korrekte Formulierung Die Rekursion ( n ) T(1) = c, T(n) = a T + t(n) b sei zu lösen. n ist eine Potenz der Zahl b > 1 und a 1, c > 0 gelte. ) (a) Wenn t(n) = O (n (log b a) ε für eine Konstante ε > 0, dann ist T (n) = Θ(n log b a ). (b) Wenn t(n) = Θ(n log b a ), dann ist T (n) = Θ(n log b a log b n). ) (c) Wenn t(n) = Ω (n (log b a)+ε für eine Konstante ε > 0 und a t ( ) n b αt(n) für eine Konstante α < 1, dann T (n) = Θ(t(n)). Siehe Beweis des Mastertheorems im Skript. Kapitel 2: Laufzeitmessung Das Mastertheorem 75 / 77

76 Die Laufzeit von Algorithmus A 3 Wir hatten die Rekursionsgleichungen Zeit A3 (1) = 1, Zeit A3 (n) = 2 Zeit A3 ( n 2 ) + 2n 1 erhalten. Um das Mastertheorem anzuwenden, müssen wir c = 1, a = 2, b = 2 und t(n) = 2n 1 setzen. In welchem Fall befinden wir uns? Es ist logb a = log 2 2 = 1 und t(n) = Θ(n log b a ). Fall (b) ist anzuwenden und liefert ZeitA3 (n) = Θ(n log 2 n). Algorithmus A 3 ist schneller als Algorithmus A 1, denn Zeit A3 (n) lim n Zeit A2 (n) = lim n log 2 n log = lim 2 n = 0. n n 3 n n 2 Kapitel 2: Laufzeitmessung Das Mastertheorem 76 / 77

77 Was kann das Mastertheorem nicht? Um das Mastertheorem anzuwenden, muss stets dieselbe Anzahl a von Teilproblemen mit derselben Eingabelänge n b rekursiv aufgerufen werden: b darf sich während der Rekursion nicht ändern. Das Mastertheorem ist nicht auf die Rekursion T (1) = 1, T (n) = T (n 1) + n anwendbar, weil b sich ändert. Gleiches gilt für die Rekursion T (1) = 1, T (n) = 2 T (n 1) + 1, die die Anzahl der Ringbewegungen in den Türmen von Hanoi zählt. Kapitel 2: Laufzeitmessung Das Mastertheorem 77 / 77