Funktionenklassen zur Messung der Komplexität Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 3 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät für Angewandte Wissenschaften Albert-Ludwigs-Universität Freiburg

Lernziele Algorithmen für wichtige Probleme : Sortieren, Suchen, Wörterbuch-Problem, Berechnung kürzester Pfade, . . . Datenstrukturen : Listen, Stapel, Schlangen, Bäume, Hash-Tabellen, . . . Problemlösetechniken : Divide-and-Conquer, Greedy, vollständige Aufzählung, Backtracking, . . . Ziele: Finden effizienter Algorithmen für Instanzen von Problemen aus einem gegebenen Bereich Fähigkeit zur Beurteilung von Algorithmen aufgrund präziser Kriterien (Korrektheit, Effizienz) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Beschreibung und Analyse von Algorithmen Mathematisches Instrumentarium zur Messung der Komplexität (des Zeit- und Platzbedarfs von Algorithmen): Groß-O-Kalkül (Landausche Symbole) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Effizienzanalyse Laufzeitkomplexität: Steht die Laufzeit im akzeptablen/ vernünftigen/ optimale Verhältnis zur Größe der Aufgabe? Speicherplatzkomplexität: Wird primärer (sekundärer) Speicherplatz effizient genutzt? Theorie: Kann untere Schranken liefern, die für jeden Algorithmus gelten, der das Problem löst (etwa (n log n) Schritte für jedes allgemeine Sortierverfahren mit n Elementen) Spezieller Algorithmus: Liefert obere Schranke für die Lösung eines Problems (etwa O(n2) Schritte für Bubblesort mit n Elementen) Effiziente Algorithmen und Komplexitätstheorie: Zweige der Theoretischen Informatik zur Erforschung von oberen und unteren Schranken Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Komplexitätsschranken Schranke für speziellen Algorithmus Komplexität des Problems Untere Schranke aus der Theorie Inputgröße Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Laufzeitanalyse (1) Ein Programm P, das für eine Problembeschreibung x mit Länge n=|x| die Lösung findet, habe Laufzeit TP (n) Der beste Fall (best case): Laufzeit meist leicht bestimmbar, kommt in der Praxis eher selten vor: TP,best(n) = inf {TP(x) | n = |x|} Der schlechteste Fall (worst case): Liefert garantierte Schranken, Laufzeit meist leicht bestimmbar, aber meist zu pessimistisch in der Praxis: TP,worst(n) = sup {TP(x) | n = |x|} Im amortisierten worst case wird der durchschnittliche Aufwand für eine schlechtestmögliche Folge von Eingaben bestimmt (technisch anspruchsvoll). Der mittlere Fall (average case): Z.B. Mittelung über alle Eingaben mit Länge n TP,average(n) = 1/(#(x)mit|x|=n) ∑|x|=n TP(x) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Messung des Leistungsverhaltens Betrachte konkrete Implementierung auf konkreter Hardware. Miss Laufzeit und Platzverbrauch für repräsentative Eingaben. Berechne Verbrauch an Platz und Zeit für idealisierte Referenzmaschine, Random Access Machine (RAM), Registermachine (RM), Turingmachine (TM), . . . Bestimme Anzahl bestimmter (teurer) Grundoperationen, etwa • # Vergleiche, # Bewegungen von Daten (beim Sortieren) • # Multiplikationen/Divisionen (für numerische Verfahren) Bei 2. und 3.: Beschreibe Aufwand eines Verfahrens als Funktion der Größe des Inputs. (Die Input-Größe kann verschieden gemessen werden.) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Beispiel: Taktzahl (1) Bestimme Aufwand (Taktzahl = Anzahl der Bitwechsel) eines Von-Neumann Addierwerks bei Addition einer 1 zu einer durch n Binärziffern gegebenen Zahl i. 0 ≤ i ≤ 2n -1 Bester Fall: Die best case Rechenzeit beträgt 1 Takt (Addiere 1 zu 000……00) Schlechtester Fall: Die worst case Rechenzeit beträgt n + 1 Takte (Addiere 1 zu 111…… 11) Die Taktzahl ist 1 plus # der 1en am Ende der Darstellung von i. Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Beispiel: Taktzahl (2) Mittlerer Fall: Angenommen wird die Gleichverteilung auf der Menge der Eingaben. Es gibt 2n-k Eingaben, die mit enden und k Takte benötigen. Die Zahl 2n - 1 braucht n + 1 Takte. Die average case Rechenzeit beträgt also Im Mittel reichen also 2 Takte, um eine Addition von 1 durchzuführen. Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Nebenrechnung Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Primitive Operationen Grundlegende Berechnungen, die von einem Algorithmus ausgeführt werden Ablesbar aus Pseudocode oder Programmstück Überwiegend unabhängig von einer (imperativen) Programmiersprache Exakte Definition ist nicht bedeutend Beispiele einen Ausdruck auswerten einer Variablen einen Wert zuweisen Indexierung in einem Array Aufrufen einer Methode Verlassen einer Methode Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Zählen von primitiven Operationen Durch Untersuchen des Pseudocode können wir die maximale Zahl von primitiven Operationen, die durch einen Algorithmus ausgeführt wurden, als eine Funktion der Eingabegröße bestimmen. Algorithmus arrayMax(A,n) # Operationen currentMax = A[0] 2 for i = 1 to n-1 do 2(n-1) if A[i] > currentMax then 2(n-1) currentMax = A[i] 2(n-1) { erhöhe Zähler i } return currentMax 1 Total 6n-3 Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Laufzeit abschätzen Der Algorithmus arrayMax führt im worst case 6n - 3 primitive Operationen aus Definiere a Zeit, die die schnellste primitive Operation verbraucht hat b Zeit, die die langsamste primitive Operation verbraucht hat T(n) sei die tatsächliche worst-case Laufzeit von arrayMax . Dann ist : Daher ist die Laufzeit T(n) durch zwei lineare Funktionen beschränkt. Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Zuwachsrate der Laufzeit Verändern der Hard- und Softwareumgebung - beeinflusst T(n) um einen konstanten Faktor, aber - ändert die Wachstumsordnung von T(n) nicht Das lineare Wachstum der Laufzeit T(n) ist eine für den Algorithmus arrayMax charakteristische Eigenschaft. Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Primitive Operationen Grundlegende Berechnungen, die von einem Algorithmus ausgeführt werden Ablesbar aus Pseudocode oder Programmstück Überwiegend unabhängig von einer (imperativen) Programmiersprache Exakte Definition ist nicht bedeutend Beispiele einen Ausdruck auswerten einer Variablen einen Wert zuweisen Indexierung in einem Array Aufrufen einer Methode Verlassen einer Methode Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Funktionenklassen Groß-O-Notation: Mit der O-, - und -Notation sollen obere, untere bzw. genaue Schranken für das Wachstum von Funktionen beschrieben werden. Idee: Konstante Summanden und Faktoren dürfen bei der Aufwandsbestimmung vernachlässigt werden. Gründe: • Man ist an asymptotischem Verhalten für große Eingaben interessiert • Genaue Analyse kann technisch oft sehr aufwendig oder unmöglich sein • Lineare Beschleunigungen sind ohnehin immer möglich (Ersatz von Hardware/Software) Ziel: Komplexitätsmessungen mit Hilfe von Funktionenklassen. Beispielsweise bezeichnet O(f) die Klasse der Funktionen, die (höchstens) von der Größenordnung von f sind. Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Die O-Notation Sei eine Funktion g: N → R+ gegeben, dann ist O(g) folgende Menge von Funktionen: Die O-Notation gibt also eine asymptotisch obere Grenze für eine Funktion. Wenn f zu O(g) gehört, sagt man: f ist Groß-O-von g und schreibt: f(n)  O(g(n)) oder auch (mathematisch fragwürdig): f(n) = O(g(n)) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Veranschaulichung der O-Notation Die Funktion f gehört zur Menge O(g), wenn es positive Konstanten c und n0 gibt, so dass f(n) ab n0 unter c g(n) liegt. n0 f(n) c g(n) n Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Die Ω -Notation Sei eine Funktion g: N → R+ gegeben, dann ist  (g) folgende Menge von Funktionen: Die  -Notation gibt also eine asymptotisch untere Grenze für eine Funktion. Wenn f zu  (g) gehört, sagt man: f ist Groß-Omega-von g und schreibt: f(n)  (g(n)) oder auch (mathematisch fragwürdig): f(n) = (g(n)) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Veranschaulichung der Ω -Notation Die Funktion f gehört zur Menge  (g), wenn es positive Konstanten c und n0 gibt, so dass f(n) ab n0 oberhalb von c g(n) liegt. n0 n f(n) c g(n) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Die Θ -Notation Sei eine Funktion g: N → R+ gegeben, dann ist  (g) folgende Menge von Funktionen: Die  -Notation gibt also eine asymptotisch feste Grenze für eine Funktion. Wenn f zu  (g) gehört, sagt man: f ist Groß-Theta-von g und schreibt: f(n)  (g(n)) oder auch (mathematisch fragwürdig): f(n) = (g(n)) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Veranschaulichung der Θ -Notation Die Funktion f gehört zur Menge  (g), wenn es positive Konstanten c1, c2 und n0 gibt, so dass f(n) ab n0 zwischen c1 g(n) und c2 g(n) eingepackt werden kann. f(n) c1g(n) c2g(n) n Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann n0

Bemerkungen zu den O-Notationen In manchen Quellen findet man leicht abweichende Definitionen, etwa Für die relevantesten Funktionen f (etwa die monoton steigenden f nicht kongruent 0) sind diese Definitionen äquivalent. Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Beispiele zur O-Notationen f(n) = 2n2 + 3n + 1 = O(n2) f(n) = n log n ist nicht in O(n) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Eigenschaften von Groß-O Transitivität: Ist f(n) = O(g(n)) und g(n) = O(h(n)), dann ist f(n) = O(h(n)) Additivität: Ist f(n) = O(h(n)) und g(n) = O(h(n)), dann ist f(n) + g(n) = O(h(n)) Für konstantes a ist: a nk = O(nk) nk = O(nk+j), für jedes positive j. f(n) = aknk + ak-1nk-1 + … + a1n1 + a0 = O(nk) Ist f(n) = c g(n) für konstantes c, so ist f(n) = O(g(n)) Für beliebige positive Zahlen a, b ≠ 1 ist f(n) = logan = O(logbn) Für beliebige positive a ≠ 1 ist logan = O(log2n) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Der O-Kalkül Einfache Regeln: f = O(f) O(O(f)) = O(f) k O(f) = O(f), für konstantes k O(f + k) = O(f), für konstantes k Additionsregel: O(f) + O(g) = O( max{f, g} ) Multiplikationsregel: O(f)  O(g) = O( fg ) Additionsregel findet Anwendung bei der Berechnung der Komplexität, wenn Programmteile hintereinander ausgeführt werden. Multiplikationsregel findet Anwendung bei der Berechnung der Komplexität, wenn Programmteile ineinander geschachtelt werden. Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Beispiele zur Laufzeitabschätzung(1) Algorithmus prefixAverages1(X) Eingabe: Ein Array X von n Zahlen Ausgabe: Ein Array A von Zahlen, so dass gilt: A[i] ist das arithmetische Mittel der Zahlen X[0], …, X[i] Methode: for i = 0 to n-1 do a = 0; for j = 0 to i do a = a + X[j] A[i] = a/(i + 1) return array A Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Beispiele zur Laufzeitabschätzung(2) Algorithmus prefixAverages2(X) Eingabe: Ein Array X von n Zahlen Ausgabe: Ein Array A von Zahlen, so dass gilt: A[i] ist das arithmetische Mittel der Zahlen X[0], …, X[i] Methode: s = 0; for i = 0 to n-1 do s = s + X[i]; A[i] = s/(i + 1) return array A Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Hierarchie von Größenordnungen Größenordnung Name O(1) konstante Funktionen O(log n) logarithmische Funktionen O(log2 n) quadratisch logarithmische Funktionen O(n) lineare Funktionen O(n log n) n log n-wachsende Funktionen O(n2) quadratische Funktionen O(n3) kubische Funktionen O(nk) polynomielle Funktionen f heißt polynomiell beschränkt ,wenn es ein Polynom p mit f = O(p) gibt. f wächst exponentiell , wenn es ein  > 0 gibt mit f =  (2n ) Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Skalierbarkeiten Annahme: 1 Rechenschritt benötigt 0.001 Sekunden. Maximale Eingabelänge bei gegebener Rechenzeit. Annahme: Es kann auf einen 10-fach schnelleren Rechner gewechselt werden. Statt eines Problems der Größe p kann in gleicher Zeit dann berechnet werden: Laufzeit T(n) 1 Sekunde 1 Minute 1 Stunde Laufzeit T(n) neue Problemgröße Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Bestimmung des Zeitaufwands Sei A ein Programmstück, dessen Zeitaufwand cost(A) zu bestimmen ist: A ist einfache Anweisung (read, write, +, -, . . . ): cost(A) = const  O(1) A ist Folge von Anweisungen: Additionsregel anwenden A ist if-Anweisung: (a) if (cond) B; cost(A) = cost(cond) + cost(B) (b) if (cond) B; else C; cost(A) = cost(cond) + max(cost(B), cost(C)) A ist eine Schleife (while, for, . . . ): A ist Rekursion . . . Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann

Implementation in Java class Mult { public static void main ( String [] args ) { int x = new Integer (args[0]). intValue(); int y = new Integer (args[1]). IntValue(); System.out.println (“Das Produkt von “ +x+ “ und “ +y+ “ ist “ +mult(x,y)); public static int mult (int x, int y) { int z = 0; while (y>0) if (y % 2 == 0) { y = y / 2; x = x+x ;} else { y = y-1; z = z+x; } return z; } } Informatik II: Algorithmen und Datenstrukturen, SS 2008 Prof. Dr. Thomas Ottmann