Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Komplexität von Algorithmen. Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen.

Ähnliche Präsentationen


Präsentation zum Thema: "Komplexität von Algorithmen. Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen."—  Präsentation transkript:

1 Komplexität von Algorithmen

2 Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen

3 Komplexität von Algorithmen Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen

4 Komplexität Nicht die Komplexität eines Algorithmus im Sinne von Kompliziertheit ist gemeint, sondern das Laufzeitverhalten, die Ausführungsgeschwindigkeit Es gibt auch Speicherplatzkomplexität, diese wird hier nicht thematisiert

5 Beispiel Rechner LRechner M A 3 Sekunden6 Sekunden B 3 Sekunden Angenommen wir haben 2 Programme A und B und deren Ausführungszeit auf den Rechnern L und M:

6 Beispiel Rechner LRechner M A3 s6 s B 3 s Mögliche Aussagen: Beide Programme sind ähnlich schnell Ausführungsgeschwindigkeit hängt vom Rechner ab Unsinnige Aussage: Programm A ist 25% schneller als Programm B

7 Beispiel Rechner LRechner M A3 s6 s B 3 s Unsinnige Aussage: Programm A ist 25% schneller als Programm B Trotzdem wird diese Aussage oft gemacht. Trick: Umrechnen der Rechenzeiten auf relative Werte Rechner LRechner MDurchschnitt A 3s 16s 1 1 B 6s 23s 0,5 1,25 Rechner LRechner MDurchschnitt A0,521,25 B111

8 Benchmarks und andere Tricks Quelle: AMD Homepage Quelle: ZDNet

9 Komplexität Komplexitätsabschätzung soll angeben, wie sich die Laufzeit eines Algorithmus nur in Abhängigkeit von der Größe des Problems entwickelt Wir werden deshalb eine Methode zur Ab- schätzung der Geschwindigkeit eines Algorithmus unabhängig von verwendeter Hardware benötigen Als Problemgröße betrachten wir den nötigen Umfang der Berechnung: z.B. Anzahl der Eingabewerte / Daten Bezeichnung: n

10 Komplexität von Algorithmen Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen

11 Laufzeit eines Algorithmus Beispiel: Algorithmus, der alle Elemente eines Arrays auf 0 setzt. Größe des Problems: Anzahl n der Array-Elemente Laufzeit f(n) auf Maschine L: (29n + 13) μs Laufzeit f(n) auf Maschine M: (17n + 52) μs Vernachlässigen wir den konstanten Summanden und den konstanten Faktor, können wir sagen, dass die Komplexität des Algorithmus von der Ordnung n ist (Lineare Ordnung). Schreibweise: f(n) O(n).

12 Groß-O-Notation a,n 0 : ( n: n n 0 : f(n) a·g(n)) mit a 0 Man kann sagen f(n) ist aus O(g(n)) [f(n) O(g(n))] oder Die Komplexität des Algorithmus ist von der Größenordnung O(g(n)), wenn gilt: Beispiele: 3n + 2 O(n) 12n 2 + 3n + 5 O(n 2 ) 23 n + n 939 O(23 n )

13 Klasse der linearen Komplexitätsfunktionen

14 Klasse der quadratischen Komplexitätsfunktionen

15 Groß-O-Notation int[] a = new int[n]; int i=0; while(i!=n) { a[i]=0; i=i+1; } Der Aufwand dieses Algorithmus ist f(n) O(n), also linear Groß-O-Notation abstrahiert nicht nur von der Maschine, sondern auch von der Anzahl der Befehle erfasst wird die Anzahl der Schritte z.B.: f(n) = 2n + 1 (nur Zuweisungen) oder f(n) = 3n + 1 (auch Vergleiche)

16 Verschiedene Komplexitätsklassen Kleine Problemgrößen: Große Problemgrößen:

17 O, Ω und Θ Die Angabe von O(n) beschreibt nur eine obere Schranke der Komplexität Insgesamt gibt es: (Groß-O, Omega und Theta) f(n) O(g(n)): a,n 0 : ( n: n n 0 : f(n) a·g(n)) mit a 0 f wächst höchstens so schnell wie g g ist obere Schranke von f f(n) Ω(g(n)): a,n 0 : ( n: n n 0 : f(n) a·g(n)) mit a 0 f wächst mindestens so schnell wie g g ist untere Schranke von f f(n) Θ (g(n)): a 1,a 2,n 0 : ( n: n n 0 : a 1 ·g(n) f(n) a 2 ·g(n)) mit a x 0 f wächst ebenso schnell wie g g ist untere und obere Schranke von f

18 Beispiel: Suchalgorithmen Lineare Suche: int i=0; while(a[i]!=x) { i=i+1; } Gesuchtes Element kann an jeder Stelle im Array stehen Komplexität: O(1) oder O(n)? Antwort: O(n), worst case: O(n) obere Schranke

19 Beispiel: Suchalgorithmen Jetzt: Beweis, dass Suchalgorithmen keine bessere Komplexität als O(log n) erreichen können, wobei n die Anzahl der zu durchsuchenden Elemente ist Annahme: Suchalgorithmus verwendet 2-Wege- Vergleiche: Wir können 2 Elemente des Arrays untereinander vergleichen, oder ein Element des Arrays mit einem speziellen Wert Ergebnis des Vergleichs ist immer true oder false

20 Beispiel: Suchalgorithmen Ablauf eines beliebigen Suchalgorithmus, der diese Annahme erfüllt: Evtl. initialisieren / Startelement ermitteln Ersten Vergleich durchführen Abhängig vom Ergebnis (true / false) etwas berechnen (Verzweigung) Zweiten Vergleich durchführen Wieder dual verzweigen Und so weiter...

21 Beispiel: Suchalgorithmen Wir könnten den Ablauf des Programms als Baum aufzeichnen: Vergleich 1 Vergleich 3 Vergleich 2 true false … 123n+1nn-1

22 Beispiel: Suchalgorithmen Wir wissen: Baum ist ein binärer Baum Insgesamt muss er min. n+1 Blätter haben, da der gesuchte Wert an jeder Stelle des Arrays stehen, oder nicht vorhanden sein könnte Der Satz: Ein binärer Baum der Höhe d besitzt höchstens 2 d Blätter. führt unmittelbar zu dem Schluss, dass ein Pfad von der Wurzel zu einem Blatt des Baumes mindestens log 2 (n+1) Knoten besitzt. Also hat die Komplexität jedes Suchalgorithmus die untere Schranke f(n) Ω (log(n)).

23 Komplexität von Algorithmen Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen

24 Schleifen int[] a=new int[n]; int[] b=new int[n]; int i=0; while(i!=n) { a[i]=0; i=i+1; } i=0; while(i!=n) { b[i]=0; i=i+1; } int[] a=new int[n]; int[] b=new int[n]; int i=0; while(i!=n) { a[i]=0; b[i]=0; i=i+1; } f(n) = (2n+1)+(2n+1) = 4n+2 f(n) O(n) Die Hintereinanderausführung von Schleifen ändert die Komplexität eines Algorithmus nicht. g(n) = 3n+1 g(n) O(n)

25 Verschachtelte Schleifen int i = 0, j = 0; while (i != n - 1) { while (j != n - 1) { if (b[j] > b[j + 1]) { swap(b[j],b[j+1]); } j++; } j = 0; i++; } Bubble-Sort: Die innere und die äußere Schleife werden jeweils (n-1)-mal durchlaufen Die Anzahl der Schritte und damit die Komplexität ist also: (n-1)·(n-1)=(n-1) 2 O(n 2 ) Die Verschachtelung von Schleifen führt zur Multi- plikation der Komplexitäten der einzelnen Schleifen.

26 Verschachtelte Schleifen int k = 0,l = 0,m = 0,n = 0; while (n != N) { if (a[n] == 0) {k++;} while (k > 7) { if (a[m] == 0) {k--;} m++; } l = max(l, n m); n++; } Programm ermittelt die Länge des längsten 7er- Segments 7er-Segment: zusammenhängender Teil des Arrays, der maximal 7 Nullen enthält nm max. 7 Nullen a[]

27 Verschachtelte Schleifen Äußere Schleife wird N- mal durchlaufen Innere Schleife wird jedes Mal maximal N- mal durchlaufen f(N) O(N 2 )? Betrachten innere Schleife: manche Durchläufe können O(N) sein, andere benötigen wesentlich weniger Schritte int k = 0,l = 0,m = 0,n = 0; while (n != N) { if (a[n] == 0) {k++;} while (k > 7) { if (a[m] == 0) {k--;} m++; } l = max(l, n m); n++; }

28 Verschachtelte Schleifen Schleifeninvariante u.A.: 0 m n N Die innere Schleife wird insgesamt maximal N-mal ausgeführt Komplexität im schlimmsten Fall O(N) in einem Durchlauf, aber auch O(N) insgesamt int k = 0,l = 0,m = 0,n = 0; while (n != N) { if (a[n] == 0) {k++;} while (k > 7) { if (a[m] == 0) {k--;} m++; } l = max(l, n m); n++; } nm max. 7 Nullen a[]

29 Verschachtelte Schleifen Komplexität im schlimmsten Fall O(N) in einem Durchlauf, aber auch O(N) über alle N Durchläufe der äußeren Schleife Die durchschnittliche Komplexität pro Durchlauf der äußeren Schleife ist O(1) Getilgte Komplexität (Amortized Complexity) nennt man die Bildung des Durchschnitts der Komplexität über alle möglichen Situationen. Die Komplexität des Algorithmus ist O(N·1)=O(N)

30 Komplexität von Algorithmen Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen

31 Binäre Suche int i = M, j = N, m; while (j != i+1) { m = (i+j) div 2; if (a[m] x) { i = m; } else if (a[m] > x) { j = m; } N M x a[] Aussage: Programm ist ineffizient, da es eigentlich sofort abbrechen könnte, wenn x gefunden wurde Statt dessen läuft es bis gilt: j=i+1

32 Binäre Suche – Verbesserte Version int i = M, j = N, m; while (j != i+1) { m = (i+j) div 2; if (a[m] < x) { i = m; } else if (a[m] = x) { i = m; j = m + 1; } else if (a[m] > x) { j = m; } Annahme: M=0 und N=2 p ; x befinde sich an allen Stellen des Arrays mit gleicher Wahrschein- lichkeit 1. Fall x ist nicht im Array vorhanden: beide Algorithmen brauchen gleich viele Schritte Vergleich der 2 Algorithmen:

33 Binäre Suche - Vergleich 2. Fall x befindet sich an einer ungeraden Position im Array: wegen N=2 p finden beide Algorithmen x erst im letzten Schritt in der Hälfte der Fälle spart der zweite Algorithmus nichts 3. Fall x befindet sich an einer geraden Stelle, deren Index durch 2 dividiert ungerade ist: der zweite Algorithmus bricht einen Schritt eher als der erst ab in einem Viertel der Fälle wird ein Schritt gespart 4. Fall in einem Achtel der Fälle werden 2 Schritte gespart und so weiter…

34 Binäre Suche - Vergleich Zweites if-Statement könnte bei Ausführung das 1,5-fache der Zeit des ersten benötigen if (a[m] x) {i = m;} else {j = m;} if (a[m] < x) {i = m;} else if (a[m] = x) {i=m;j=m+1;} else {j = m;} Wann lohnt sich der zweite Algorithmus?

35 Komplexität von Algorithmen Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen

36 Man sollte besser die Komplexität eines Algorithmus verbessern als ihn im Detail feinzutunen Wichtigkeit eines effizienten Algorithmus nimmt mit schnelleren Computern nicht ab, sondern zu: Programm AProgramm B 3·10 9 ·n μs2n μs2n μs Programm AProgramm B n=370n=40 Beide Programme können in rund einem Tag ein Problem der Größenordnung n=37 lösen Wird der Rechner 10-mal schneller, schaffen sie an einem Tag:

37 Komplexität von Algorithmen Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen


Herunterladen ppt "Komplexität von Algorithmen. Was ist Komplexität? Die Groß-O-Notation Komplexität von Schleifen Effizienz-Beispiel Schlussfolgerungen."

Ähnliche Präsentationen


Google-Anzeigen