SS10 Algorithmen und Datenstrukturen Vorbemerkungen und 1. Kapitel

SS10 Algorithmen und Datenstrukturen Vorbemerkungen und 1. Kapitel Martin Dietzfelbinger April 2010 Hörer: Informatikstudierende im 2. Semester. Andere Interessenten sehr willkommen! Material: Eigene Notizen! Folienkopien, Übungsblätter auf der folgenden Webseite: http://www.tu-ilmenau.de/fakia/aud_ss10.html Zugang auch über die Fachgebietsseite. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 1 Zur Arbeitsweise: Der Stoff ist zu kompliziert und zu umfangreich, um durch reines Zuhören verstanden zu werden. Regelmäßig Vorlesung nacharbeiten. Semesterbegleitend! Begleitend Bücher ansehen. Übungsblätter drucken, lesen, zur Übung mitbringen, vorher Lösung ausdenken, Lösungsweg aufschreiben, an Lösungen mitarbeiten, Lösungen vortragen. Regelmäßig Übungen nacharbeiten. Semesterbegleitend! Bei Verständnisproblemen frühzeitig fragen! Prüfungsstoff: Vorlesung + Übungsaufgaben. Prüfung: Klausur (90 Minuten). 90 Punkte. 15 Bonuspunkte über Zwischenklausur (31.05., 30 Minuten). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 2 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 3

Übung Dr. Lucia Draque Penso Mittwoch 9:00 10:30 Sr HU 117 Beginn: 14.04. Donnerstag 9:00 10:30 Sr HU 013 Beginn: 15.04. Freitag 13:00 14:30 Sr K 2035 Beginn: 16.04. Übungsblätter (im Netz) Übung vor- und nachbereiten! Grundlagen, Voraussetzungen Prof. Günter Schäfer, Algorithmen und Programmierung für Informatiker, WS 2009/10 http://www.tu-ilmenau.de/fakia/algorithmen-und-prog.aup0.0.html Wird vorausgesetzt! G. Saake, K. U. Sattler. Algorithmen und Datenstrukturen - Eine Einführung mit Java. dpunkt.verlag, 3. Auflage, 2006. Prof. D. Rautenbach: Grundlagen und diskrete Strukturen, Vorlesung, WS 2009/10 Wird vorausgesetzt! FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 4 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 5 Literatur R. H. Güting, S. Dieker, Datenstrukturen und Algorithmen, 2. Auflage, Teubner 2003. T. Ottmann, P. Widmayer, Algorithmen und Datenstrukturen, Spektrum Akademischer Verlag, 4. Auflage, 2002. T. Cormen, C. Leiserson, R. Rivest, C. Stein, Introduction to Algorithms, Second Edition, MIT Press 2001. (Auch auf deutsch erhältlich.) K. Mehlhorn, P. Sanders, Algorithms and Data Structures: The Basic Toolbox, Springer-Verlag, 2008 R. Sedgewick, Algorithms, Addison-Wesley, 2002 (auch C-, C++, Java-Versionen, auch auf deutsch bei Pearson) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 6 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 7

Listen, Stacks, Queues Datenstrukturen! Kapitel 1 Einführung und Grundlagen Einfache Suchbäume Balancierte Suchbäume Hashtabellen implementieren Wörterbücher Heaps implementieren Vorrangswarteschlangen (Priority Queues) Union-Find-Strukturen Datenstrukturen für Graphen FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 8 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 9 Graph: 1 2 Spezifikation des Verhaltens von Datenstrukturen (vereinfacht): 6 3 (Abstrakte) Datentypen 5 4 Digraph / gerichteter Graph: 1 2 Syntax: Signatur Semantik: Mathematisches Modell (Axiomatisch: Logische Strukturen ) 6 3 5 4 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 10 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 11

Algorithmen! Aufgabe: Für jede beliebige gegebene Folge a 1,a 2,...,a n von natürlichen / ganzen / reellen Zahlen von Objekten aus einem total geordneten Bereich (U, <) Z.B.: Zahlentupel, Strings (Zeichenreihen), mit Namen versehene Datensätze, usw. sortiere a 1,a 2,...,a n in aufsteigende Reihenfolge. Vorher: (5, 2, 9, 3, 6, 5, 8) Nachher: (2, 3, 5, 5, 6, 8, 9) Sortieren durch Einfügen (Insertion Sort) Eingabe (a 1,...,a n ) in Array (Feld) A[1..n] Idee: Für i =2, 3,...,n: Suche die Stelle in der sortierten Version von a 1,...,a i 1, an die a i gehört, und füge a i dort ein. Pseudocode: Algorithmus Straight Insertion Sort (1) for i from 2 to n do (2) x A[i].key ; (3) j i-1 ; (4) while j 1 and x < A[j].key do (5) A[j+1] A[j] ; (6) j j-1 ; (7) A[j+1] x. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 12 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 13 Was ist ein Algorithmus? Erklärung: Ein Algorithmus A ist eine durch einen endlichen Text gegebene Verarbeitungsvorschrift, die zu jeder gegebenen Eingabe x aus einer Menge I (Menge der möglichen Eingaben) eindeutig eine Reihe von auszuführenden Schritten vorschreibt. Wenn nach endlich vielen Schritten diese Ausführung anhält, wird ein Ergebnis A(x) ausgegeben. Mögliche Formen: Umgangssprache, Pseudocode, Programm in Programmiersprache, Programm für formales Maschinenmodell, Programm in Maschinensprache. Allgemeine Merkmale eines Algorithmus Endlicher Text Ein Algorithmus für eine große (oft: unendliche!) Menge von Eingaben x (Beachte: Zeitliche Trennung der Formulierung des Algorithmus/der Programmierung und der Anwendung auf eine Eingabe.) Eindeutig vorgeschriebene Abfolge von Schritten, wenn Eingabe x vorliegt Wenn Verarbeitung anhält: Ausgabe ablesbar Nicht verlangt: Terminierung auf allen x I. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 14 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 15

Erweiterungen des Algorithmusbegriffs Online-Algorithmen: Die Eingabe wird nicht am Anfang der Berechnung, sondern nach und nach zur Verfügung gestellt Häufige Situation bei Datenstrukturen Standard bei Betriebssystemen, Systemprogrammen, Anwendungsprogrammen mit Benutzerdialog usw. Randomisierung: Algorithmus führt Zufallsexperimente durch Verteilte Algorithmen : Mehrere Rechner arbeiten zusammen, kommunizieren, zeitliche Abfolge nicht vorhersagbar in dieser Vorlesung nicht oder nur am Rande diskutiert Algorithmen in dieser Vorlesung: Darstellung von Algorithmen, Bausteine für Algorithmen (besonders Iteration, Rekursion) Analyse 1: Korrektheit von Algorithmen, Induktionsbeweise für iterative und rekursive Verfahren Analyse 2: Laufzeitbegriff, O-Notation, Laufzeitanalyse Algorithmen zur Implementierung von Datentypen Balancierte Suchbäume, einfache Hashverfahren Sortierverfahren (Quicksort, Heapsort, Mergesort, CountingSort), Medianbestimmung FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 16 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 17 Grundbegriffe der Graphentheorie Grundlegende Algorithmen für Graphen: Breitensuche, Tiefensuche, Zusammenhangskomponenten, Entdecken von Kreisen, minimale Spannbäume Algorithmus Straight Insertion Sort (Pseudocode) (1) for i from 2 to n do (2) x A[i] ; (3) j i-1 ; (4) while j 1 and x.key < A[j].key do (5) A[j+1] A[j] ; (6) j j-1 ; (7) A[j+1] x. Fragen: (a) Ist dieser Algorithmus korrekt? (b) Wie lange braucht der Algorithmus, um die Berechnung zu beenden? FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 18 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 19

(a) Korrektheitsbeweise Damit die Frage nach einem Beweis der Korrektheit sinnvoll ist, müssen wir die zu lösende Aufgabe spezifizieren. Bemerkung: Aus einer vagen Problemstellung eine präzise Spezifikation des zu lösenden Problems zu gewinnen ist ein in der Praxis extrem wichtiger Schritt, dessen Bedeutung oft unterschätzt wird. Berechnungsprobleme Erklärung: Ein Berechnungsproblem P besteht aus (i) einer Menge I von möglichen Eingaben ( Inputs, Instanzen ) (I kann unendlich sein!) (ii) einer Menge O von möglichen Ausgaben (iii) einer Funktion f : I O Ein Algorithmus A löst P, wenn A genau die Eingaben aus I verarbeitet und zu Eingabe x I Ausgabe A(x) =f(x) liefert. Spezialfall O = {1, 0} = {true, false} = {Ja, Nein} (Entscheidungsproblem) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 20 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 21 Varianten Zu einer Eingabe x I gibt es mehrere legale Ergebnisse. Formal: In (iii) haben wir statt einer Funktion f eine Relation R I Omit: x I y O: R(x, y). A löst P, wenn A genau die Eingaben aus I verarbeitet und R(x, A(x)) für jedes x I gilt. Beispiel: Beim Sortieren von Datensätzen (k, d k ), wobei ein Schlüssel k wiederholt vorkommen darf, ist jede sortierte Anordnung eine legale Lösung. Online-Situation: Eingabe wird in Raten geliefert, Zwischenausgaben werden verlangt. Spezifikation des Sortierproblems Parameter: Der Grundbereich, aus dem die zu sortierenden Objekte stammen, ist ein Parameter der Spezifikation. (U, <): eine total geordnete Menge (endlich oder unendlich). Siehe Mathematik-Vorlesung) Beispiele: Zahlenmengen {1,...,n}, N, Q, Q; Mengen von Strings. D: Eine Menge (von Datensätzen ). Jeder Datensatz a hat einen Sortierschlüssel : key: D U. I = O = Seq(D) =D < = n 0 Dn = {(a 1...,a n ) n N,a 1,...,a n D}, FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 22 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 23

die Menge aller endlichen Folgen von Datensätzen. Beispiel: U = N, D = N {a,...,z} key : D (i, b) i U Ein möglicher Input: x = ((5, p), (3, q), (9, a), (6, q), (5, a), (4, u), (5, z)). Das Ergebnis beim Sortieren sollte z. B. sein: y = ((3, q), (4, u), (5, z), (5, a), (5, p), (6, q), (9, a)). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 24 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 25 x =(a 1,...,a n ) I und y =(b 1,...,b m ) Ostehen in der Relation R genau dann wenn n = m und es gibt eine Permutation π von {1,...,n} mit b i = a π(i), 1 i n, und key(b 1 ) key(b 2 ) key(b n ). Beispiel: Für x = ((5, p), (3, q), (9, a), (6, q), (5, a), (4, u), (5, z)) und y = ((3, q), (4, u), (5, z), (5, a), (5, p), (6, q), (9, a)) ( ) 1 2 3 4 5 6 7 wäre π = passend. 2 6 7 5 1 4 3 Alternative Formulierung für die Spezifikation einer Lösung des Sortierproblems: O = {π π Permutation einer Menge {1,...,n},n N} Definition: x =(a 1,...,a n ) wird durch π sortiert, wenn key(a π(1) ) key(a π(2) ) key(a π(n) ) gilt. x =(a 1,...,a n ) und π stehen in der Relation R, wenn x durch π sortiert wird. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 26 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 27

Löst Straight Insertion Sort das Sortierproblem? Gilt für jede Eingabe (a 1,...,a n ) in A[1..n], dass nachher dieselben Elemente im Array stehen, aber nach Schlüsseln aufsteigend sortiert? Korrektheitsbeweis an Beispiel: Durch vollständige Induktion über i =1, 2,..., n zeigt man die folgende Behauptung: (IB i ) Nach Durchlauf Nummer i (in i) der äußeren Schleife stehen in A[1..i] dieselben Elemente wie vorher, aber aufsteigend sortiert. I.A.: i =1: Nach Durchlauf für i =1 ist vor Beginn. Anfangs ist das Teilarray A[1..1] (nur ein Eintrag) sortiert. I.V.: (IB i 1 ) gilt, d. h.a[1..i 1] ist sortiert, und Schleifendurchlauf i beginnt. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 28 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 29 Ind.-Schritt: Betrachte Schleifendurchlauf i. Die innere Schleife (2) (7) transportiert x = A[i] (via x) an die Position j unmittelbar rechts von dem Eintrag in A[1..i 1] mit dem größten Schlüssel, der key(x) ist. Oder an Position 1, wenn key(a[i]) kleiner als alle Schlüssel in A[1..i 1] ist. Die Einträge A[j],...,A[i 1] werden um eine Position nach rechts verschoben, um für A[i] Platz zu machen. Ind.-Beh. (IB i ) erfüllt. Methoden für Korrektheitsbeweise Diskrete Mathematik Vollständige Induktion Schleifen Wesentlich: Formulierung der Induktionsbehauptung. Schleifeninvariante. Andere Formen der Induktion Rekursive Prozeduren Also gilt (IB n ), also ist nach Abschluss des Ablaufs das Array sortiert. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 30 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 31

Kosten, Aufwand, Eingabe x abläuft. (b) Laufzeitanalysen Rechenzeit, wenn Algorithmus A auf Eingabegröße: n = x = size(x). (Bedeutung ist abhängig von Problem P.) I n = {x I size(x) =n} Größenklasse Beim Sortierproblem: size((a 1,...,a n )) = n. Kosten für Elementaroperationen: Addition, Vergleich, Test, Sprung, Zuweisung, Auswertung eines Attributs, Zeiger-/Indexauswertung Abhängig von Programmiersprache, Compiler, Prozessor, Hauptspeichertyp, Cachestruktur,... Unabhängig vom konkreten Input x. Wir schreiben: O(1) für: nicht größer als eine (von x unabhängige) Konstante c (z.b. c op,für eine Operation op) Gesamtlaufzeit: Nicht größer als die Summe aller Konstanten für die Einzeloperationen. Entscheidend: Wie oft wird jede Operation ausgeführt? FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 32 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 33 Beispiel: Straight Insertion Sort (1) (3) und (7): Wird (n 1)-mal ausgeführt. Es gibt aber n Schleifenende-Tests Kosten n O(1) = O(n) (4) (6) für i: Entscheidend: Anzahl der Tests in (4). Der Test j 1 wird zwischen 1-mal und i-mal durchgeführt, der Test x.key < A[j].key zwischen 1-mal und (i 1)-mal, inputabhängig. Setze k i =#{l l<iund key(a i ) < key(a l )}. Kosten für (4) (6) bei a i : (k i +1) O(1) = O(k i ). Notation: #A oder A : Kardinalität von A. Kosten insgesamt: O(n)+(k 2 +1) O(1)+(k 3 +1) O(1) + +(k n +1) O(1) = = O(n + k i ). 2 i n Typisch: Charakteristische Operationen sind entscheidend, Hier: Vergleiche zwischen Elementen (Zeile (4)), Anzahl k i +1. Oder: Zuweisungen von Elementen (Zeilen (5) und (7)), Anzahl k i +1. Definition: F x = 2 i n k i = #{(l, i) 1 l < i n, key(a l ) > key(a i )} FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 34 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 35

Anzahl der Fehlstände in x =(a 1,...,a n ) Z. B. gibt es in (4, 7, 5, 3) vier Fehlstände. Worst case (Schlechtester Fall): k i = i 1, für alle i, d. h. x ist absteigend sortiert. Beispiel: x = ((11, a), (9, q), (8, p), (7, a), (5, z), (4, u), (2, q)). Wegen F x = n(n 1) 2 i n (i 1) = 2 < n2 2 : Gesamtaufwand für S.I.S.: O(n + n 2 )=O(n 2 ). Best case (Bester Fall): k i =0,für alle i. Beispiel: x = ((2, q), (4, u), (5, z), (7, a), (8, p), (9, q), (11, a)), Aufwand pro Durchlauf durch Schleife (2) (7): O(1) Gesamtaufwand für S.I.S.: n O(1) = O(n). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 36 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 37 Fazit: Selbst für feste Implementierung eines Algorithmus A auf fester Maschine und feste Eingabegröße n = size(x) = x kann der Berechnungsaufwand höchst unterschiedlich sein. Begriff Laufzeit von Algorithmus A auf Eingaben x vom Umfang n = size(x) ist meist sinnlos. Sinnvoll: Obere Schranken O-Notation. Und: Untere Schranken Ω-Notation. Konstante Faktoren ignorieren! Average case (Mittlerer Fall): Vereinfachung: Für alle i j: key(a i ) < key(a j ) oder key(a i ) > key(a j ). Unter der Annahme, dass jede Anordnung der Schlüssel (a 1,...,a n ) mit derselben Wahrscheinlichkeit 1/n! auftritt (Beispiel bei Schlüsseln 2, 3, 7: (2, 3, 7), (2, 7, 3), (3, 2, 7), (3, 7, 2), (7, 2, 3), (7, 3, 2): je 1 6 ) bilde Mittelwert/Erwartungswert für F x = 2 i n k i. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 38 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 39

Kann Erwartungswert berechnen: E(F x )= 1 2 (n) 2 = 1 4n(n 1) (Grund: In jeder Anordnung (a 1,...,a n) der Schlüssel kann man Einträge an Positionen l und i vertauschen. Einmal liefert das Paar (l, i) einen Fehlstand, einmal nicht. Daher führt jedes der ( ) n 2 Paare (l, i) mit Wahrscheinlichkeit genau 1 2 zu einem Fehlstand, trägt also 1 2 zur erwarteten Anzahl der Fehlstände bei.) Aufwand von Straight Insertion Sort im mittleren Fall, auf Inputs der Länge n, unter der Gleichverteilungsannahme: O(n 2 ), aber auch Ω(n 2 ) Zusammengefasst: Θ(n 2 ). Kosten Rechenzeiten Gegeben: Algorithmus A für Inputmenge I. Beispiel: Algorithmus Straight Insertion Sort (Pseudocode) (1) for i from 2 to n do (2) x A[i] ; (3) j i-1 ; (4) while j 1 and x.key < A[j].key do (5) A[j+1] A[j] ; (6) j j-1 ; (7) A[j+1] x. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 40 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 41 Kosten Rechenzeiten Jede Elementaroperation op ist mit einer Konstanten c op bewertet. Idee: op benötigt höchstens Zeit c op (Takte oder μs) Die Konstanten c op werden nie explizit genannt; vereinfachend oft: c op =1( 1 RAM-Schritt ). Grund: Analyse des Algorithmus anhand von Pseudocode o.ä. Technische Besonderheiten von konkreten Rechnern (Cachearchitekturen, Mehrkernprozessoren, Coprozessoren,... ), Implementierungen, Compileroptimierungen zu berücksichtigen wäre viel zu komplex! Kosten Rechenzeiten k op (x) sei die Anzahl der Ausführungen der Elementaroperation op bei der Ausführung von A auf x. Dann: t A (x) := oder im Fall c op =1: t A (x) := op Operation op Operation k op (x) c op. k op (x) =#(ausgeführte Op.). Wir nennen t A (x) die Kosten von A auf x. Ungefähres Maß für die Rechenzeit! Oft Rechenzeit statt Kosten. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 42 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 43

Größenordnungen von Funktionen Notation: N = {0, 1, 2, 3,...} N + = {n N n>0} = {1, 2, 3,...} R + 0 = {x R x 0} R + = {x R x>0} Uns interessieren meistens (als Rechenaufwand oder Abschätzungen hierfür) nur Funktionen, die schließlich positiv oder nichtnegativ sind. Abkürzung: F + := {f f : N R, n 0 n n 0 : f(n) > 0}. F + 0 := {f f : N R, n 0 n n 0 : f(n) 0}. O-Notation Informal: g ist von der Ordnung f (Notation O(f)), wenn: n 0 Für genügend große n ist 0 g(n) c f(n), für c>0 konstant. g 2 f f FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 44 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 45 Formal: Definition Sei f F +. O-Notation O(f) := { g F 0 + n 0 N c >0 n n 0 : g(n) c f(n)} g O(f) heißt, dass g asymptotisch (für genügend große n) und unter Vernachlässigung konstanter Faktoren höchstens so schnell wächst wie f. Beispiele: O-Notation (a) Wenn g(n) =2n + 7 log n und f(n) =n, dann ist g O(f). (b) Wenn g(n) =2n + 7 log n und f(n) =n 2, dann ist g O(f). (c) Wenn g(n) =4n 3 13n 2 +10und f(n) =n 3 log n, dann ist g O(f). (d) Wenn g(n) = 3+2 sin(n) und f(n) = 1, dann ist g O(f). (e) Wenn g(n) =2n für gerade n und g(n) =2/n für ungerade n, und f(n) =n, dann ist g O(f). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 46 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 47

O(f(n))-Notation Schreib- und Sprechweisen: (i) g(n) =O(f(n)) als Abkürzung für g O(f). (ii) g(n) ist O(f(n)). Sprich: g(n) ist Groß-Oh von f(n) Warnung: Das = bedeutet nicht Gleichheit, ist nicht symmetrisch. Intuition: O(f(n)) steht für ein beliebiges Element von O(f). (Eine anonyme Funktion g F 0 +, von der man nur weiß, dass sie für genügend große n durch c f(n) beschränkt ist.) Damit z. B. auch sinnvoll: 3n 3 +2n 2 5n +4=3n 3 + O(n 2 ). Beispiele: (a) 2n + 7 log n = O(n). O(f(n))-Notation (b) Jede Funktion g mit 2n log n g(n) 4n 2 / log n für alle n 10 erfüllt g(n) =O(n 2 ). (c) 2n 2 30n +3=O(n 2 ). (d) 4 2 n +3 n 2 =4 2 n + O(n 2 )=O(2 n ). (e) 4n 2 log n +2n(log n) 3 =4n 2 log n + O(n 2 )=O(n 3 ). (e ) 4n 2 log n +2n(log n) 3 = O(n 2 log n). (f) 3 + 2 sin(n) =O(1). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 48 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 49 Konvention: Möglichst kleine und möglichst einfache Funktionen innerhalb des O(...)-Terms. 17n 2 /(log n) 3 +13n 3/2 = O(n 2 /(log n) 3 ) (klein) oder 17n 2 /(log n) 3 +13n 3/2 = O(n 2 ) (besonders einfach) o-notation g(n) wächst asymptotisch streng langsamer als f(n). f g FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 50 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 51

Definition Für f F + : o(f) := o-notation { g F + 0 lim n g(n) } f(n) =0 Ω-Notation g(n) ist asymptotisch und bis auf einen konstanten Faktor durch f(n) nach unten beschränkt. f Schreibe g(n) =o(f(n)) für g o(f). (Sprich: g(n) ist klein-oh von f(n).) Beispiele: (a) n/ log n = o(n). (b) 5n 2 log n +7n 2.1 = o(n 5/2 ). (c) n 10 = o(2 n ). n 0 g f /2 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 52 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 53 Definition Sei f F +. Ω-Notation Ω(f) := {g F + n 0 N d >0 n n 0 : g(n) d f(n)} Schreibe g(n) =Ω(f(n)) für g Ω(f). (Sprich: g(n) ist Groß-Omega von f(n).) Beispiele: (a) 0.3n log n 20n =Ω(nlog n). (b) 1 10 n2 20n +1=Ω(n 2 ). (c) n 10 log n =Ω(n 10 ). Manchmal benutzt: Für f F + : ω(f) := {g F + g(n) lim n f(n) = } g(n) wächst asymptotisch echt schneller als f. Schreibe g(n) =ω(f(n)) für g ω(f). (Sprich: g(n) ist klein-omega von f(n).) Klar: Für f,g F + gilt: g ω(f) f o(g). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 54 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 55

Θ-Notation g(n) ist asymptotisch und bis auf konstante Faktoren von derselben Größenordnung wie f(n). g 2 f f Θ-Notation Für f F + definiere: Θ(f) := O(f) Ω(f), d.h. Θ(f) = {g F + n 0 N c, d > 0 n n 0 : d f(n) g(n) c f(n)} Beobachtung: g Θ(f) O(g) =O(f). Schreibe g(n) =Θ(f(n)) für g Θ(f). (Sprich: g(n) ist Theta von f(n).) f /2 n 0 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 56 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 57 Rechenregeln Lemma 1 (Grenzwertregel) Falls f F +,g F 0 + und lim n g(n) f(n) = c für ein c 0, so ist g(n) =Θ(f(n)). Spezialfälle: c =0: Voraussetzung bedeutet: g(n) =o(f(n)). Also: g(n) =o(f(n)) g(n) =Θ(f(n)) g(n) c>0: lim n f(n) = c impliziert: Es gibt n 0, so dass für n n 0 gilt: c/2 < g(n) f(n) < 2c. Also: g(n) =Θ(f(n)). Rechenregeln Folgerung aus der Grenzwertregel: Wenn g ein Polynom ist: g(n) =a k n k + a k 1 n k 1 + + a 1 n + a 0 für a k,...,a 1,a 0 R, wobei a k > 0, und f(n) =n k, dann lim n g(n) ( f(n) = lim a k + a k 1 n n + + a 1 n k 1 + a ) 0 n k = a k, damit: a k n k + a k 1 n k 1 + + a 1 n + a 0 =Θ(n k ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 58 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 59

Rechenregeln Lemma 2 (Transitivität) Es seien f,g F +. Dann gilt für jedes h F 0 + : Wenn g(n) =O(f(n)) und h(n) =O(g(n)), dann folgt h(n) =O(f(n)). D.h.: Wenn g O(f), dann ist O(g) O(f). Kurz: h(n) =O(g(n)) = O(f(n)). Achtung: In der O(f(n))-Notation bedeutet = keine Gleichheit, die Relation ist nicht symmetrisch. Rechenregeln Lemma 3 ( Konstante Faktoren weglassen ) Ist g(n) =O(d f(n)) und d>0 beliebig, dann gilt g(n) =O(f(n)). D.h.: Wenn d>0, dann ist O(d f) =O(f). Beispiele: Nicht g(n) =O(3n log 2.8 n), sondern g(n) =O(n log n); nicht g(n) =O(n/3), sondern g(n) =O(n); nicht g(n) =O(2.5), sondern g(n) =O(1). Analog bei o( ), Ω( ), ω( ), Θ( ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 60 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 61 Rechenregeln Lemma 4 (Linearität und Maximumsregel) Ist g 1 (n) =O(f 1 (n)) und g 2 (n) =O(f 2 (n)), so folgt g 1 (n)+g 2 (n) = O(f 1 (n)+f 2 (n)) = O(max{f 1 (n),f 2 (n)}). Beispiele: 10n log n +5n 2 = O(n log n)+o(n 2 )=O(n 2 ). 10n log n +5n 2 =Θ(nlog n)+θ(n 2 )=Θ(n 2 ). 10n log n +5n 2 =Ω(nlog n)+ω(n 2 )=Ω(n 2 ). Anwendung: Hintereinanderausführung von Algorithmen: Rechenzeiten addieren sich, auch in der O-Abschätzung. Analog bei o( ), Ω( ), ω( ), Θ( ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 62 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 63

Rechenregeln Lemma 5 (Weglassen von Termen kleinerer Ordnung ) Ist f F + und g(n) = o(f(n)), und ist h(n) =O(f(n)+g(n)), so ist h(n) =O(f(n)). Analog bei o( ), Ω( ), ω( ), Θ( ). Fazit: In Summen suche den dominierenden Term ; lasse die anderen weg. Rechenregeln Lemma 6 (Multiplikationsregel) Ist g 1 (n) =O(f 1 (n)) und g 2 (n) =O(f 2 (n)), so folgt g 1 (n)g 2 (n) =O(f 1 (n)f 2 (n)). Analog bei o( ), Ω( ), ω( ), Θ( ). Bei o( ) genügt sogar: g 1 (n) =O(f 1 (n)) und g 2 (n) =o(f 2 (n)). Anwendung: Sei g 1 (n) =O(f 1 (n)) und g 2 (n) =O(f 2 (n)). Wird eine Schleife g 1 (n)-mal ausgeführt, wobei die Kosten für die einmalige Ausführung höchstens g 2 (n) betragen, dann sind die Gesamtkosten O(f 1 (n)f 2 (n)). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 64 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 65 Rechenregeln O-Notation in Summen Beispiel: Unterschiedliche Kosten für Schleifenrumpf bei verschiedenen Durchläufen. n Durchläufe, Kosten beim i-ten Durchlauf: O(n 2 i ). Maximum: O(n 2 n ). Multiplikationsregel liefert: O(n (n 2 n )) = O(n 2 2 n ). Aber: 2+2 2 +2 3 + +2 n 1 +2 n =2 n+1 2=O(2 n ). Vermutung: Gesamtkosten sind nur O(n 2 n ). Rechenregeln Lemma 7 (O-Notation in Summen) Sei g : N N R + 0. Für jedes n N sei a n,1,...,a n,t(n) Zahlenfolge mit c >0 n 0 n n 0 1 i t(n) :0 a n,i c g(n, i). ( a n,i ist uniform durch ein Vielfaches von g(n, i) beschränkt ; man schreibt kurz: a n,i = O(g(n, i))) Dann gilt (die Variable ist n): a n,i = O g(n, i) 1 i t(n) 1 i t(n) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 66 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 67

Achtung! Wenn es für jedes n n 0 ein c n gibt mit 1 i t(n) :0 a n,i c n g(n, i), (a n,i nicht-uniform beschränkt), dann kann man nicht folgern, dass ist. 1 i t(n) a n,i = O 1 i t(n) g(n, i) O-Notation bei Kosten Beispiel Straight Insertion Sort, Eingabe x: Mit Multiplikationsregel: Der i-te Durchlauf durch die äußere Schleife hat Kosten Θ(1)+ k i Θ(1) = Θ(1 + k i ), wobei k i =#{l <i key(a l ) > key(a i )} (abhängig von x!). Mit Summationsregel: Der gesamte Ablauf hat Kosten t S.I.S (x) =Θ(n + k i )=Θ(n + F x ). 2 i n F x : Anzahl der Fehlstände l<i, key(a l ) > key(a i ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 68 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 69 Kosten Rechenzeiten Oft: Detaillierte Aussagen für einzelne Inputs gar nicht erwünscht. Vergröberung: Größenklassen Eingabegröße: n = x = size(x). I n = {x I size(x) =n} Größenklasse Beim Sortierproblem z. B.: size((a 1,...,a n )) = n Worst-case-Kosten worst-case-kosten oder Kosten im schlechtesten Fall: Sei A Algorithmus für Inputs aus I. I n = {x I size(x) =n} worst-case-kosten: T A (n) = max{t A (x) x I n } Wenn man betonen will, dass es um die worst-case Kosten geht: T A,worst (n). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 70 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 71

Worst-case-Kosten Beispiel S.I.S.: Für den Input x =(n, n 1,...,1) gilt n + F x = n + Für jeden Input gilt 2 i n n + F x n + 2 i n (i 1) = n + (i 1) = n + Also: T S.I.S.,worst (n) =Θ(n + n 2 )=Θ(n 2 ). n(n 1). 2 n(n 1). 2 Best-case-Kosten best-case-kosten oder Kosten im besten Fall: T A,best (n) = min{t A (x) x I n } Beispiel S.I.S.: Für den Input (1, 2,...,n) gilt n + T x = n +0=n; für jeden Input gilt n + 2 i n k i n. Also: T S.I.S.,best (n) =O(n), sogar =Θ(n). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 72 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 73 Average-case Kosten average-case-kosten oder durchschnittliche Kosten: Gegeben sei, für jedes n N, eine Wahrscheinlichkeitsverteilung Pr n auf I n. D.h.: Für jedes x I n ist eine Wahrscheinlichkeit Pr n (x) festgelegt. (Empirisch, oder per Festlegung.) T A,av (n) = E(t A )= x I n Pr n (x) t A (x). (Erwartungswert, berechnet mit Pr n ; Mittelwert ) Average-case Kosten Beispiel S.I.S.: Wahrscheinlichkeitsannahme (Standard für das Sortierproblem): Alle Schlüssel n der Eingabe verschieden, jede Anordnung der Eingabeobjekte hat dieselbe Wahrscheinlichkeit 1/n!. Jedes Paar von Positionen (l, i) ist mit W. 1 2 ein Fehlstand. E(F x )= 1 2 (n) 2 = 1 4n(n 1) Aufwand von Straight Insertion Sort im mittleren Fall, auf Inputs der Länge n, unter der genannten Gleichverteilungsannahme: T S.I.S,av (n) =Θ(n + 1 4 n(n 1))=Θ(n2 ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 74 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 75

Analyse von Kosten Fazit Fazit: Selbst für feste Implementierung eines Algorithmus A auf fester Maschine und feste Eingabegröße n = size(x) = x kann der Berechnungsaufwand auf verschiedenen Inputs sehr unterschiedlich sein. Begriff Die Laufzeit von Algorithmus A auf Eingaben x vom Umfang n = size(x) ist meist sinnlos. Sinnvoll: Schlechtester und bester Fall, durchschnittlicher Fall. Analyse von Kosten Fazit In allen drei Situationen (worst c., best c., average c.): Obere Schranken O-Notation. Untere Schranken Ω-Notation. Asymptotisches Verhalten, präzise: Θ-Notation. Konstante Faktoren ignorieren! FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 76 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 77 Ignorieren konstanter Faktoren Beispiel: Alternativer Sortieralgorithmus: Mergesort. (1. Sem.) Rechenzeit/Kosten: Θ(n log n). Mergesort wird für genügend große Inputs schneller sein als Straight Insertion Sort, auch wenn wir die Konstanten nicht kennen. Ein Vergleich: 10n log n versus n 2 /5 50000 40000 30000 n log n versus n*n, bis n=500 20000 10000 0 100 200 300 400 500 x 10*n*log n n*n/5 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 78 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 79

Ein Vergleich: 10n log n versus n 2 /5 Ein Vergleich: 10n log n versus n 2 /5 1.8e+06 n log n versus n*n, bis n=3000 2e+07 n log n versus n*n, bis n=10000 1.6e+06 1.4e+06 1.2e+06 1.5e+07 1e+06 800000 1e+07 600000 400000 5e+06 200000 0 500 1000 1500 2000 2500 3000 x 10*n*log n n*n/5 0 2000 4000 6000 8000 10000 x 10*n*log n n*n/5 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 80 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 81 Ein Vergleich: 10n log n versus n 2 /5 Wachstumsordnungen 1e+11 8e+10 6e+10 4e+10 2e+10 0 n log n versus n*n, bis n=1000000 200000 400000 600000 800000 1e+06 x 10*n*log n n*n/5 Einfach : Funktionen mit unterschiedlich schnellem Wachstum bilden Hierarchie. Beispiele (s. Übung): f 1 (n) = log log n, f 2 (n) = log n, f 3 (n) =(logn) 2, f 4 (n) = n, f 5 (n) = n log n, f 6(n) =n, f 7 (n) =n log n, f 8 (n) =n(log n) 2, f 9 (n) =n 3/2, f 10 (n) =n 2, f 11 (n) =n 3, f 12 (n) =2 n, f 13 (n) =n 5 2 n, f 14 (n) =e n, f 15 (n) =3 n f 16 (n) =(n/e) n, f 17 (n) =n!, f 18 (n) =n n. f i+1 (n) in folgendem Sinn: lim =, für 1 i 17. n f i (n) Bem.: In dieser Vorlesung: log x bedeutet log 2 x. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 82 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 83

Vergleich einiger Wachstumsordnungen Zeit für eine (Elementar-)Operation: 10 ns. t A (n) 10 100 1000 10 4 10 5 10 6 10 7 10 8 log n 33ns 66ns 0.1μs 0.1μs 0.2μs 0.2μs 0.2μs 0.3μs n 32ns 0.1μs 0.3μs 1μs 3.1μs 10μs 31μs 0.1ms n 100ns 1μs 10μs 0.1ms 1ms 10ms 0.1s 1s n log n 0.3μs 6.6μs 0.1ms 1.3ms 16ms 0.2s 2.3s 27s n 3/2 0.3μs 10μs 0.3ms 10ms 0.3s 10s 5.2m 2.7h n 2 1μs 0.1ms 10ms 1s 1.7m 2.8h 11d 3.2y n 3 10μs 10ms 10s 2.8h 115d 317y 3.2 10 5 y 1.1 n 26ns 0.1ms 7.8 10 25 y 2 n 10μs 4.0 10 14 y n! 36ms 3.0 10 142 y n n 1.7m 3.2 10 184 y n Hilft ein schnellerer Rechner? Wie wächst die maximal behandelbare Eingabegröße, wenn der Rechner um den Faktor 10 schneller wird? t A (n) Max alt Max NEU log n n n 10 n n 100n n n 10n log n n log n n 10n log n+log 10 n 3/2 n 4.64n n 2 n 3.16n n 3 n 2.15n n k n 10 1/k n c n n n + log c 10 n! um von n auf n +1zu kommen, n n braucht man einen um den Faktor n schnelleren Rechner FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 84 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 85 Hilft ein schnellerer Rechner? Angetrieben durch die höheren Rechengeschwindigkeiten und die noch rascher wachsenden Speicherkapazitäten wächst in vielen Bereichen die Menge der zu bewältigenden Daten noch schneller als die Rechnergeschwindigkeit. Beispiele: Indizes der Internet-Suchmaschinen. Routenplaner, Fahrplan-, Ticketsysteme der Bahn. Computergraphik (Szenen aus zig Milliarden von Elementen!) Effizienz der benutzten Algorithmen ist wichtiger denn je! FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS10 Kapitel 0+1 86