12. September 2012 Kompexität. Analyse von Algorithmen (Ziele) Empirische Analyse Beispiel Schlussfolgerungen

Transkript

1 Komplexität von Algorithmen Ferd van Odenhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering 12. September 2012 ODE/FHTBM Komplexität von Algorithmen 12. September /41 (Ziele) (Ziele) Effizienzbetrachtungen für grundlegende Algorithmen Gründe für eine (mathematische) verschiedene Algorithmen für eine Aufgabe vergleichen ihre Effizienz systemunabhängig vorhersagen die Werte von Algorithmus-Parametern setzen Es gibt mathematische Formeln, mit denen sich Maße für Algorithmen und ihre Güte bzgl. Effizienz vorhersagen lassen. Wir unterscheiden zwei Strategien für die Effizienzbetrachtung emprisiche Analyse Komplexitätsklassen ODE/FHTBM Komplexität von Algorithmen 12. September /41 (Ziele) Eigenschaften von Algorithmen - Algorithmus-Analyse Wie ermitteln Sie die Eigenschaften von Algorithmen? Prüfen Sie die Operationen auf den Daten Prüfen Sie die Eingabedaten Wie bestimmen wir die Effizienz von Algorithmen? Wir benutzen folgende Methoden für bestehende Implementierungen Implementierung und empirische Analyse Algorithmen-Analyse vor der Implementierung zur Beschreibung von Komplexitätsklassen Groß-Oh Notation und O-Notation Garantien, Vorhersagen, Grenzen ODE/FHTBM Komplexität von Algorithmen 12. September /41 1

2 (Ziele) Implementierung und empirische Analyse Algorithmen als Berechnungsverfahren werden entworfen, indem wir Operationen auf (Daten-)Strukturen betrachten oder (Daten-)Strukturen wählen, von denen wir wissen, dass gewisse Operationen schnell angewendet werden können. Um eine gute Implementierung, z.b. in Java, zu finden, müssen wir immer abwechselnd diese Ansätze betrachten und gegeneinander abwägen. Somit kann es üblich sein mit einer bestehenden Implementierung (aus der Java Programmbibliothek) zu starten. Wir können von einer konkreten Implementierung lernen. ODE/FHTBM Komplexität von Algorithmen 12. September /41 Empirische Analyse (Ziele) Wir beginnen mit einer bestehenden Implementierung. Was lässt sich durch eine empirische Analyse herausfinden? Was liefert uns eine Betrachtung der tatsächlichen Laufzeit? Nehmen Sie zwei Algorithmen an, die das selbe Problem lösen sollen. Wir starten beide, um festzustellen, welcher länger braucht! Dass ein Algorithmus zehnmal so schnell wie der andere ist, fällt wohl jeder oder jedem auf, die 3 Sekunden auf den einen und 30 Sekunden auf den anderen warten; Stimmt ein solcher Testlauf für alle möglichen Eingaben der beiden folgenden Algorithmen? Beispiel: Summation einer endlichen Zahlenfolge ODE/FHTBM Komplexität von Algorithmen 12. September /41 (Ziele) Summation einer endlichen Zahlenfolge (nicht im Buch) 1. Implementierung public int Ga ussian SumSim ple ( int n) { int sum =0; for ( int i = n; n > 0; i - -) { sum = sum + i; return sum ; Für N = 30 werden beim Schleifendurchlauf 30 Additionen ausgeführt. Für N = 300 werden beim Schleifendurchlauf 300 Additionen ausgeführt, also das 10-fache. Gleich soviel als das Wachstum von N. ODE/FHTBM Komplexität von Algorithmen 12. September /41 2

3 (2) (Ziele) Summation einer endlichen Zahlenfolge (nicht im Buch) zweite Implementierung public int GaussianSum ( int n) { int sum = 0.5* n*(n +1); return sum ; Für eine feste Anzahl z.b. N = 30: N = 30 sum = (30 + 1) = 1860 Eine Addition und zwei Multiplikationen werden gebraucht. Wenn N = 300 sum = ( ) = Eine Addition und zwei Multiplikationen werden gebraucht. Die Anzahl gebrauchte Operationen ist unabhängig vom Wert N. ODE/FHTBM Komplexität von Algorithmen 12. September /41 (Ziele) Zusammenfassung Beispiel Summation Summation einer endliche Zahlenfolge In der ersten Implementierung haben wir einen Aufwand in Relation zur Größe der Eingabe; d.h. der Aufwand wird höher umso größer N ist. Der Aufwand wächst linear. In der zweiten Implementierung ist der Berechnungsaufwand unabhängig von der Eingabegröße N. Wir sagen der Aufwand ist konstant. Offensichtlich kann die Laufzeit von der Eingabe abhängen. Nicht immer ist es möglich diese Abhängigkeit auszuschließen, aber es ist immer einen Versuch wert. Überlegen Sie, was passiert bei festen N. ODE/FHTBM Komplexität von Algorithmen 12. September /41 Empirische Analyse (Ziele) Empirische Studien nehmen viel Zeit in Anspruch. Bevor wir sie vergleichen können, müssen wir die Algorithmen implementiert haben. Es kann dann Minuten, Stunden oder Tage dauern, bis wir das gewünschte Ergebnis haben. Untersuchung der Eingabedaten Drei Auswahlmöglichkeiten reale Daten Zufallsdaten pervertierte Daten ODE/FHTBM Komplexität von Algorithmen 12. September /41 3

4 Empirische Analyse (Ziele) Reale Daten erlauben uns eine Laufzeitmessung des verwendeten Programms (in seinem SW-System). Zufallsdaten sorgen dafür, dass unsere Experimente die Algorithmen testen, nicht die Daten. Pervertierte Daten stellen sicher, dass unser Programm mit beliebigen Eingaben fertig wird. ODE/FHTBM Komplexität von Algorithmen 12. September /41 Kritik an der empirischen Analyse (Ziele) Verschiedene Faktoren entziehen sich dem Einfluss der Programmierenden, z.b. Programmier-Umgebungen, zb. für Java oder.net Java Programme werden in Byte-Code, und dieser Byte-Code wird auf einer virtuellen Maschine (VM) in Ablauf-Code übersetzt. Sowohl der Compiler (Übersetzer) als auch die VM-Implementierungen wirken sich darauf aus, wie die tatsächliche Maschine die Anweisungen ausführt. Kompiler-Optionen bieten Möglichkeiten diesen Prozess zu beeinflussen. Eingabedaten Viele Programme werden stark von den Eingabedaten beeinflusst und ihre Laufzeit kann abhängig von der Eingabe - stark schwanken. Programme (oder Implementierungen) sind schwer verständlich. ODE/FHTBM Komplexität von Algorithmen 12. September /41 (Ziele) Empirische Analyse () Empirische Tests können wir nicht für ein Programm durchführen, das noch nicht geschrieben und mit [Massen-] Eingabedaten gestartet worden ist, aber wir können Eigenschaften des Programms analysieren und die potenzielle Wirksamkeit von Verbesserungen abschätzen. Wir können in unseren Implementierungen bestimmte Parameter verwenden und die Analyse dazu nutzen, uns beim Setzen der Parameter zu helfen. Ziel: wenn wir die grundlegenden Eigenschaften unserer Programme verstehen und im Prinzip wissen, wie die Programme Ressourcen nutzen, können wir potenziell auch bewerten, wie effektiv sie auf noch nicht gebauten Computern sein werden. Wir können sie auch mit Algorithmen vergleichen, die noch nicht entworfen worden sind. ODE/FHTBM Komplexität von Algorithmen 12. September /41 4

5 Wie führen Sie diese durch? Bei der Analyse eines Algorithmus müssen Sie die Operationen identifizieren. Es kann eine große Anzahl von Operationen geben. Grundsätzlich hängt die Leistung von Algorithmen aber nur von wenigen Größen ab, die leicht zu erkennen sind, indem Sie beispielsweise ein Profil anlegen (die Anzahl der Anweisungen zählen). ODE/FHTBM Komplexität von Algorithmen 12. September /41 Für eine Analyse des ungünstigsten Falls ermitteln Sie die Laufzeit-Komplexität (Obergrenze abhängig von dem gewählten Eingabeparameter N) oder Speicherplatz-Komplexität (Obergrenze abhängig von der Nutzung des Speicherplatzes). Beachten Sie, dass sich die Ergebnisse von Laufzeit-Komplexität in Speicherplatz-Komplexität umwandeln lassen, und von Speicherplatz-Komplexität in Laufzeit-Komplexität. Diese Messungen von Komplexität lassen sich als Wachstum der Funktionen zeigen, wobei Sie Groß-Oh Notation verwenden. ODE/FHTBM Komplexität von Algorithmen 12. September /41 Eigenschaften von Algorithmen Fehlerfreiheit Invarianten von Schleifen Methoden-Invarianz Wie Sie effiziente Algorithmen bestimmen Speicherplatz-Komplexität Laufzeit-Komplexität gemeinsame Kostenmaße bester Fall, ungünstigster Fall, durchschnittlicher Fall ODE/FHTBM Komplexität von Algorithmen 12. September /41 5

6 Ein typische mathematische Funktion wird benutzt zur Anzeige der Komplexität eines Algorithmus. Die meisten Algorithmen haben einen primären Parameter N, der die Laufzeit am stärksten beeinflusst. Parameter N könnte sein Grad der Polynomialität, Größe der Datei, die sortiert oder durchsucht werden soll, Anzahl Zeichen in der Zeichenkette, oder andere Maßeinheit für die Größe des Problems, das untersucht wird. Häufig ist es direkt proportional zur Größe der Datenmenge, die verarbeitet wird. Damit verwenden wir ein vereinfachtes Modell, in dem wir uns darauf beschränken, nur den einen Parameter N zu betrachten. ODE/FHTBM Komplexität von Algorithmen 12. September /41 Wir wollen die Anforderungen an die Ressource (Laufzeit oder Speicherplatz) durch N ausdrücken und dabei mathematische Formeln verwenden, die für große Parameterwerte korrekt sind (um dadurch das Implementierungsproblem und das Problem der Massen-Eingabedaten zu überwinden). Algorithmen bewirken typischerweise eine Laufzeit-Komplexität in Abhängigkeit von den folgenden Funktionen, siehe die folgenden Folien. Beachten Sie, dass wir damit eine Klassifikation für alle Algorithmen erhalten. ODE/FHTBM Komplexität von Algorithmen 12. September /41 // return number of distinct triples (i, j, k) // such that a[ i] + a[ j] + a[ k] = 0 public static int count ( int [] a) { int N = a. length ; int cnt = 0; for ( int i = 0; i < N; i ++) { for ( int j = i +1; j < N; j ++) { // N=N^1 for ( int k = j +1; k < N; k ++) { // (N ^2)/2 if (a[i] + a[j] + a[k] == 0) { // {N ^3/6 cnt ++; return cnt ; ODE/FHTBM Komplexität von Algorithmen 12. September /41 6

7 Abbildung: : 1, log(x), x, x log(x), x 2, x 3,.. ODE/FHTBM Komplexität von Algorithmen 12. September /41 : 1 Konstante Laufzeit Die meisten Anweisungen der meisten Programme werden nur ein oder höchstens einige wenige Male ausgeführt. Wenn das für alle Anweisungen eines Programms zutrifft, sagen wir, dass das Programm eine konstante Laufzeit hat. Zum Beispiel: Verdopplung der Eingabelänge hat fast kein Einfluss auf die Laufzeit. ODE/FHTBM Komplexität von Algorithmen 12. September /41 : logn Logarithmische Laufzeit Wenn die Laufzeit eines Programms logarithmisch ist, wird das Programm geringfügig langsamer, wenn N größer wird. Dieser Laufzeit-Effekt tritt üblicherweise in Programmen auf, die ein großes Problem dadurch lösen, dass sie es in eine Reihe kleinerer Probleme umwandeln, wobei sie die Größe des Problems in jedem Schritt um einen konstanten Faktor verringern. Zum Beispiel: Verdopplung vermehrt die Laufzeit mit ein konstanter Beitrag. In dem Bereich, der uns interessiert, können wir die Laufzeit als kleiner als eine große Konstante betrachten. Die Basis des Logarithmus verändert die Konstante, allerdings nicht stark. ODE/FHTBM Komplexität von Algorithmen 12. September /41 7

8 : N Lineare Laufzeit Wenn die Laufzeit eines Programms linear ist, bedeutet das im Allgemeinen, dass jedes Element der Eingabe nur wenig bearbeitet wird. Diese Situation ist optimal für einen Algorithmus, der N Eingaben bearbeiten muss (oder Prozedur N Ausgaben). ODE/FHTBM Komplexität von Algorithmen 12. September /41 : NlogN NlogN Laufzeit Die NlogN Laufzeit entsteht, wenn Algorithmen ein Problem lösen, indem sie es in kleinere Subprobleme zerlegen, die unabhängig gelöst werden, um dann die Lösungen zu kombinieren. Wenn sich N verdoppelt, wird die Laufzeit etwas (aber nicht viel) mehr als verdoppelt. ODE/FHTBM Komplexität von Algorithmen 12. September /41 : N 2 und N 3 N 2 Wenn die Laufzeit eines Algorithmus quadratisch ist, eignet sich dieser Algorithmus in der Praxis nur für relativ kleine Probleme. Quadratische Laufzeiten entstehen typischerweise bei Algorithmen, die Paare von Datenelementen verarbeiten (möglicherweise in einer doppelt verschachtelten Schleife) N 3 Analog hat ein Algorithmus, der Tripels von Datenelementen verarbeitet (möglicherweise in einer dreifach verschachtelten Schleife) eine kubische Laufzeit. Verdoppelt sich N, so verachtfacht sich die Laufzeit. ODE/FHTBM Komplexität von Algorithmen 12. September /41 8

9 : 2 N Es gibt nur wenige Algorithmen mit exponentieller Laufzeit, die sich für die Praxis eignen. Solche Algorithmen sind aber das natürliche Ergebnis von brute-force Lösungen für Probleme. Wenn sich N verdoppelt, wächst die Laufzeit im Quadrat! 2 (2 N) = (2 N ) 2 ODE/FHTBM Komplexität von Algorithmen 12. September /41 Werte von übliche Funktionen lgn N N NlgN N(lgN) 2 N 3/2 N ODE/FHTBM Komplexität von Algorithmen 12. September /41 : Spezielle Funktionen Funktion Beschreibung Beispiel Annäherung für große Werte x Bodenfunktion 3.14 = 3 x x Deckefunktion 3.14 = 4 x lgn Binärer Logarithmus lg(1024) = ln(N) F N Fibonacci Zahlen F 10 = 55 φ N / 5 H N Harmonische Zahlen (Summe) sum = ln(n) + γ N! Fakultät-funktion 10! = (N/e) N lg(n!) lg(10!) 520 Nlg(N) 1.44N ODE/FHTBM Komplexität von Algorithmen 12. September /41 9

10 : Spezielle Konstanten Constant Value e = γ = φ = (1 + 5)/2 = ln(2) = lg(e) = 1/ln(2) = ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) Einige Vorüberlegungen Mit die Effizienz von Algorithmen vergleichen In den meisten Fällen entscheidet sich die Effizienz von Algorithmen damit, wie die (mathematischen) Operationen auf einer Datenstruktur implementiert sind. Andererseits beeinflusst aber auch die ausgewählte, zu Grunde liegende Datenstruktur die Effizienz. Algorithmen können also schneller werden, wenn wir die Datenstruktur ändern. Was bedeutet schnell oder langsam? ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) von f(n) Zur Begrenzung des Fehlers, den wir machen, wenn wir kleine Ausdrücke in Formeln ignorieren Zur Begrenzung des Fehlers, den wir machen, wenn wir die Teile eines Programms ignorieren, die nur wenig zu dem Ganzen beitragen, das wir analysieren Um uns Algorithmen anhand der Obergrenzen ihrer Gesamtlaufzeit klassifizieren zu lassen schnell und langsam lassen sich ermitteln, dargestellt durch O-Notation: O(f (N)) - Groß-Oh von f (N) Die O-Notation beschreibt die Relation ist proportional zu. Wie erwähnt, ist die Untersuchung der Eingabe eine asymptotische Herangehensweise an den ungünstigsten Fall. ODE/FHTBM Komplexität von Algorithmen 12. September /41 10

11 von f(n) Wachstum von Funktionen: Verhalten für großes N f (N) f (N) = N 2 f (N) = Nlog(N) N ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) O-Notation: O(f (N)) - Groß-Oh von f (N) O(f (N)) - Groß-Oh von f (N) Grob gesagt: Die Menge der Funktionen, die nicht schneller als konstante f (N)-Mal zunehmen, wenn N groß wird. Dabei ist N die (Größe oder Länge der) Eingabe(-Daten). Präzise ausgedrückt: Die Menge der Funktionen g(n) : N R wird als O(f (N)) bezeichnet, wenn für jedes g(n) die Konstanten c 0 R + und N 0 N existieren, so dass zutrifft: g(n) c 0 f (N) für alle N > N 0 Tücke: Zwar würden wir einen Algorithmus, der N 2 Nanosekunden braucht, einem vorziehen, der mehr als logn Jahrhunderte braucht, aber diese Entscheidung könnten wir nicht auf der Basis von O-Notation treffen. ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) Grundsätzlich können wir Ausdrücke erweitern, indem wir O-Notation so verwenden, als wäre das O nicht vorhanden, und dann bis auf den größten Ausdruck alle fallen lassen. Wenn wir beispielsweise diesen Ausdruck erweitern: (O(N) + O(1))(O(N) + O(logN) + O(1)) erhalten wir sechs Summanden O(N 2 ) + O(NlogN) + O(N) + O(N) + O(logN) + O(1) ODE/FHTBM Komplexität von Algorithmen 12. September /41 11

12 von f(n) Wir können alle O-Ausdrücke bis auf die größten fallen lassen, womit die Annäherung bleibt: O(N 2 ) + O(NlogN). O(N 2 ) ist eine gute Annäherung an diesen Ausdruck, wenn N groß ist. Diese Formel mit einem O-Ausdruck bezeichnen wir als einen asymptotischen Ausdruck. ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) g(n) = 3N N logN O(N 3 ) g(n) = 3N N logN O(N 4 ) g(n) = g(n) = { 5N, N N 2, N > { N 2, N N, N > enthält auch: O(N 2 ) O(N) ODE/FHTBM Komplexität von Algorithmen 12. September /41 Beispiel: Das Sieb des Eratosthenes von f(n) class Primes { public static void main ( String [] args ) { int N = integer. parseint ( args [0]); boolean [] a = new boolean [ N]; for ( int i = 2; i < N; i ++) a[ i] = true ; for ( int i = 2; i < N; i ++) if ( a[ i]!= false ) for ( int j = i, i* j < N; j ++) a[i*j] = false ; for ( int i = 2; i < N; i ++ ) if ( i > N ) if (a[i]) System. out. println (" " + i); System. out. println (); ODE/FHTBM Komplexität von Algorithmen 12. September /41 12

13 von f(n) Das Sieb des Eratosthenes - Komplexität In der Implementierung gibt es vier Schleifen, von denen drei sequenziell auf die Array-Elemente zugreifen, vom Beginn zum Ende. Die sequenzielle Verarbeitung ist entscheidend. Wir könnten die erste Schleife folgendermaßen ändern: for(i = N-1; i > 1; i--) a[i] = true; Diese Änderung hat total kein Effekt! In einer Analyse der Laufzeit ist das proportional zu N + N/2 + N/3 + N/5 + N/7 + N/ das kleiner ist als N + N/2 + N/3 + N/ Die erste N Summanden dieser Folge: N (1 + 1/2 + 1/3 + 1/ /N) = N H N = O(N logn) H N : harmonic numbers sum ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) Wir haben zwei Methoden untersucht, um Algorithmen zu analysieren Empirische Analyse Komplexitätsklassen ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) Zusammenfassung - Empirische Analyse Implementierung muss existieren. (Massen-)Daten müssen vorhanden sein. Laufzeitmessungen, ggf. unter Berücksichtigung von Systemeinflüssen Schrittweise, möglicherweise sehr kostenintensive Verbesserungen durch Kenntnis von (Neben-)Bedingungen einer speziellen Anwendung Solche (Neben-)Bedingungen können im Einzelfall sehr schnelle Einzellösungen liefern. ODE/FHTBM Komplexität von Algorithmen 12. September /41 13

14 von f(n) sklassen Beim Entwurf eines Algorithmus Konzentration auf die möglichen Eingabedaten ggf. Restriktion auf einen Eingabeparameter und die langsamsten Programmteile Abschätzung des wesentlichen Eingabeparameters mittels Laufzeitkomplexität oder Speicherplatzkomplexität Bestimme eine Komplexitätsklasse, zu der ein Algorithmus gehört. Die Komplexität eines Algorithms gegeben durch die kleinste obere Schranke für Eingaben im schlechtesten Fall. Die kleinste obere Schranke ist gegeben durch das Wachstum einer mathematischen Funktion. ODE/FHTBM Komplexität von Algorithmen 12. September /41 von f(n) Jedes implementierte Programm hat eine Laufzeit. Die Komplexitätsanalyse liefert mit der kleinsten oberen Schranke die schnellste Laufzeit im schlechtesten Fall (oder den benötigten Speicherplatz) jedes Algorithmus bzgl. der mathematischen Operationen. Wir erhalten Kenntnis über die Komplexitätsanalyse die beste Lösung, die gleichzeitig eine absolute Grenze bildet. Die Programmlaufzeit eines implementierten muss nicht der Laufzeit entsprechen, die durch eine Komplexitätsklasse beschrieben wird. Wir wollen in diesem Kurs Algorithmen für die zumeist verwendeten Operationen die besten Algorithmen kennenlernen. ODE/FHTBM Komplexität von Algorithmen 12. September /41 14