Komplexität von Algorithmen

Präsentation zum Thema: "Komplexität von Algorithmen"—  Präsentation transkript:

1 Komplexität von Algorithmen

2 Komplexität von Algorithmen
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 L Rechner M A 3 Sekunden 6 Sekunden B
Angenommen wir haben 2 Programme A und B und deren Ausführungszeit auf den Rechnern L und M: Rechner L Rechner M A 3 Sekunden 6 Sekunden B

6 Beispiel Mögliche Aussagen: Beide Programme sind ähnlich schnell
Rechner L Rechner M A 3 s 6 s B 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 Unsinnige Aussage:
Rechner L Rechner M A 3 s 6 s B Unsinnige Aussage: Programm A ist 25% schneller als Programm B Trotzdem wird diese Aussage oft gemacht. Trick: Umrechnen der Rechenzeiten auf relative Werte Rechner L Rechner M Durchschnitt A 3s ≙ 1 6s ≙ 1 1 B 6s ≙ 2 3s ≙ 0,5 1,25 Rechner L Rechner M Durchschnitt A 0,5 2 1,25 B 1

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

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 Als Problemgröße betrachten wir den nötigen Umfang der Berechnung: z.B. Anzahl der Eingabewerte / Daten Bezeichnung: n Wir interessieren uns für große n Wir werden deshalb eine Methode zur Ab-schätzung der Geschwindigkeit eines Algorithmus unabhängig von verwendeter Hardware benötigen

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 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: ∃a,n0: (∀n: n ≥ n0: f(n) ≤ a·g(n)) mit a ≥ 0 Beispiele: 3n + 2 ∈ O(n) 12n2 + 3n + 5 ∈ O(n2) 23n + n939 ∈ O(23n) O(n) = „obere Schranke“; f(n), g(n) positiv

13 Klasse der linearen Komplexitätsfunktionen
Abgeschätzt wird die Polynom-Funktion nach oben durch die Lineare Funktion

14 Klasse der quadratischen Komplexitätsfunktionen
Abgeschätzt wird die

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 Θ (Groß-O, Omega und Theta)
Die Angabe von O(n) beschreibt nur eine obere Schranke der Komplexität Insgesamt gibt es: f(n) ∈ O(g(n)): ∃a,n0: (∀n: n ≥ n0: 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,n0: (∀n: n ≥ n0: f(n) ≥ a·g(n)) mit a ≥ 0 „f wächst mindestens so schnell wie g“ „g ist untere Schranke von f“ Wichtig: Element-Schreibweise, nicht = Wir nehmen meist O(n) als worst-case -> höchste Garantiewirkung f(n) ∈ Θ(g(n)): ∃a1,a2,n0: (∀n: n ≥ n0: a1·g(n) ≥ f(n) ≥ a2·g(n)) mit ax ≥ 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 Einfache Schleife: O(n)

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 … 1 2 3 n+1 n n-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 2d Blätter. führt unmittelbar zu dem Schluss, dass ein Pfad von der Wurzel zu einem Blatt des Baumes mindestens log2(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 Die Hintereinanderausführung von Schleifen ändert die Komplexität eines Algorithmus nicht. int[] a=new int[n]; int[] b=new int[n]; int i=0; while(i!=n) { a[i]=0; i=i+1; } i=0; b[i]=0; f(n) = (2n+1)+(2n+1)= 4n+2 ⇒ f(n) ∈ O(n) 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; } g(n) = 3n+1 ⇒ g(n) ∈ O(n)

25 Verschachtelte Schleifen
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(n2) 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++; Array-Größe: n Die Verschachtelung von Schleifen führt zur Multi-plikation der Komplexitäten der einzelnen Schleifen.

26 Verschachtelte Schleifen
m max. 7 Nullen a[] 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 Berechnet Länge des längsten 7er-Segments in einem Array 7er-Segment: Teil des Arrays, der maximal 7 Nullen enthält

27 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++; Äußere Schleife wird N-mal durchlaufen Innere Schleife wird jedes Mal maximal N-mal durchlaufen ⇒ f(N) ∈ O(N2)? Betrachten innere Schleife: manche Durchläufe können ∈ O(N) sein, andere benötigen wesentlich weniger Schritte

28 Verschachtelte Schleifen
m max. 7 Nullen a[] 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++; 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

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. O(1)=O(N)/O(N) In Java: Vector mit schrittweiser Vergrößerung ⇒ 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 N M x a[] 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; 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 Komplexität: \in O(log n)

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) j = m + 1; else if (a[m] > x) j = m; Vergleich der 2 Algorithmen: Annahme: M=0 und N=2p; 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

33 Binäre Suche - Vergleich
2. Fall x befindet sich an einer ungeraden Position im Array: wegen N=2p 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) else if (a[m] = x) {i=m;j=m+1;} Wann lohnt sich der zweite Algorithmus? Einfacherer Algorithmus ist besser!!! Nix mit O(x) mehr, hier Low-Level-Optimierung

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

36 Schlussfolgerungen 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 A Programm B 3·109·n μs 2n μs 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: Programm A Programm B n=370 n=40

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