4 Effizienz und Komplexität 3.1 1

Transkript

1 4 Effizienz und Komplexität 3.1 1

2 Effizienz (efficiency): auf den Ressourcen-Verbrauch bezogene Programmeigenschaft: hohe Effizienz bedeutet geringen Aufwand an Ressourcen. Typische Beispiele: Speichereffizienz (Bytes): Code und Daten möglichst kompakt Laufzeiteffizienz (Zeit): Programm läuft möglichst schnell Aber: Laufzeiteffizienz kostet Speicher Speichereffizienz kostet Laufzeit Faustregel: Speicherbedarf Laufzeit konstant Achtung: effizient nicht verwechseln mit effektiv (= tatsächlich durchführbar ) 3.1 2

3 Komplexität (complexity): auf den Ressourcen-Verbrauch bezogene Eigenschaft eines Algorithmus oder eines Problems, formuliert als Funktion der Problemgröße (Umfang der Eingabedaten): Geringe Komplexität bedeutet geringen Ressourcen-Verbrauch. Typische Beispiele: Speicherkomplexität: gemessen in Dateneinheiten Laufzeitkomplexität: gemessen in Zeiteinheiten! Effizienz eines Programms hängt ab von Komplexität des Algorithmus, Umsetzung des Algorithmus in das Programm, Effizienz des vom Übersetzer erzeugten Objektcodes

4 Sprachgebrauch: mit Effizienz ist i.a. Laufzeiteffizienz gemeint, wenn nicht explizit anderes gesagt ist.... und nie vergessen: lieber ineffizient korrekt rechnen als effizient ein falsches Ergebnis produzieren! 3.1 4

5 4.1 Laufzeitanalyse Aufgabe: Bestimme für einen vorgegebenen Algorithmus oder ein konkretes Programm die Laufzeit T. T ist abhängig von Problemgröße n (z.b. Anzahl zu sortierender Daten) - d.h. T ist Funktion von n: T(n) Ergebnis (z.b. Position eines in einem Feld gesuchten Werts) - günstigster, ungünstigster, mittlerer Fall - - T min (n), T max (n), T mit (n) Aufwand der Einzelschritte - abhängig vom Übersetzer und (wenn absolute Zeiten interessieren) von der Hardware 3.1 5

6 Beispiel 1 - Lineares Suchen: Bestimme die Position in einer Wertefolge, an der ein vorgegebener Wert x steht: betrachte erste Position; solange Position nicht x enthält, betrachte nächste Position. Oder als Programm: int i = 0; while(a[i]!=x) i++; 3.1 6

7 Annahme: jede Zeile im Algorithmus benötigt den gleichen Aufwand : 1 Zeiteinheit. Günstigster Fall: x ist erstes Element: T min = 2 Ungünstigster Fall: x ist letztes Element: T max = 2n Mittlerer Fall : T mit = n+1 = Erwartungswert über alle möglichen Fälle (die als gleichwahrscheinlich angenommen werden): T mit = ( n) / n = 2n(n+1)/2 / n = n

8 Beispiel 2 - Suchen mit Einschachteln (2.1.3 ) wiederhole: betrachte Intervallmitte; wenn gefunden, FERTIG; sonst wenn betrachteter Wert kleiner als gesuchter, betrachte rechtes Teilintervall, sonst betrachte linkes Teilintervall. Annahme: die erste Zeile benötigt den Aufwand a, jede weitere Zeile benötigt einen Aufwand b<a

9 Die Analyse ist einfach im Fall n = 2 k -1 (2.1.3, S. 13): Günstigster Fall: x ist mittleres Element: T min = a+b Ungünstigster Fall: x wird beim letzten Schritt gefunden: T max = a+b+(k-1)(a+3b) = a+b+(a+3b)(log 2 (n+1)-1) Mittlerer Fall : T mit =... < a+b+(a+3b)(log 2 (n+1)-1) Beweis: Summe der Laufzeiten für jede einzelne Position bilden und durch n teilen

10 Bei 2 k -1 < n < 2 k+1-1 wird im ungünstigsten Fall ein Schritt mehr gebraucht: T max = a+b+k(a+3b) = a+b+(a+3b) log 2 (n+1)

11 L max L mit E max E mit L min (Lineares Suchen) E min (Einschachteln)

12 4.2 O-Notation dient der Beschreibung des Wachstumsverhaltens von Funktionen, wird benutzt zur Charakterisierung von Laufzeiten T(n). Gegeben: f, g : N R Die Schreibweise bedeutet f = O(g) oder f O(g) m N, c R+ n m f(n) c g(n) Mit anderen Worten: f(n)/g(n) bleibt beschränkt für n oder: f wächst höchstens so schnell wie g

13 Beispiele: f(n) = (n-1)/3 = n/3-1/3 = O(n) weil f(n)/n = 1/3-1/(3n) 1/3 für n 1 f(n) = n(n+1)/2 = n 2 /2 +n/2 = O(n 2 ) weil f(n)/n 2 = 1/2 + 1/(2n) 1 für n 1 f(n) = /n = O(1) weil f(n)/1 = /n 4712 für n 1 aber auch f(n) = 5n - 1 = O(n 3 )! weil f(n)/n 3 = 5/n 2-1/n 3 5 für n

14 f(n) = log a n = O(log b n) weil log a n = log a b log b n, d.h. log a n / log b n = log a b = konstant! d.h. das Wachstum von log n hängt nicht von der Basis ab f(n) = log(n+1) = O(log n) weil log(n+1)/log n = = (log n + log(n+1) - log n) / log n = 1 + (log(1+1/n) / log n) 1 für n, also z.b. 2 ab einem gewissen n

15 Vergleich des Wachstums von Funktionen: Wächst f(n) schneller als g(n)? Untersuche, wie sich f(n)/g(n) für n verhält! Beispiel: Wächst log n oder n schneller?? lim n log n / n?? Bernoulli-de l Hospital! = lim n (1/n) / (1/2 n) = lim n 2/ n = 0... also wächst n schneller als log n ( und es gilt log n = O( n) )

16 Damit einfacher: lim n log(n+1) / log n = lim n (1/n) / (1/n) =

17 Andere Os - mit der Schreibweise f < g für g wächst schneller als f : f = O(g) f = o(g) f g f < g f = Θ(g) f = g und damit auch g = Θ(f) f = ω(g) f > g und damit auch g = o(f) f = Ω(g) f g und damit auch g = O(f)

18 4.3 Komplexität von Algorithmen Wenn T(n) = O(g(n)), dann sagt man: Typische Komplexitäten: Der Algorithmus hat die Komplexität O(g(n)) O(1) konstant z.b. Kopf einer Liste bestimmen O(log n) logarithmisch z.b. Suchen mit Einschachteln O(n) linear z.b. lineares Suchen O(n log n) z.b. gute Sortierverfahren O(n k ), k>1 polynomiell z.b. schlechte Sortierverfahren, O(n 2 ) O(k n ), k>1 exponentiell z.b. nichtlineare Rekursion

19 Regeln für die Komplexität zusammengesetzter Anweisungen: Sequenz zweier Anweisungen mit T 1 (n) und T 2 (n): T 1 (n) = O(f(n)) T 2 (n) = O(g(n)) O(f(n)), falls g=o(f) T(n) = T 1 (n) +T 2 (n) = O(g(n)), falls f=o(g) Alternative mit T 1 (n) bzw. T 2 (n): ebenso Schleife mit R(n) für den Rumpf, k(n)-mal durchlaufen: R(n) = O(g(n)) k(n) = O(f(n)) T(n) = k(n) R(n) = O(f(n) g(n))

20 Rekursion: T(n) ist rekursiv definiert durch eine Rekurrenzgleichung (Rekursionsgleichung) Beispiel 1: Einschachtelungsverfahren mit n=2 k -1, ungünstigster Fall: t(k) = c + t(k-1) t(0) = 0 wird gelöst durch t(k) = c k (Beweis durch Einsetzen!) Also ist T(n) = c log 2 (n+1) = O(log n)

21 Beispiel 2: Türme von Hanoi T(n) = c + 2 T(n-1) T(0) = 0 wird gelöst durch T(n) = c (2 n -1) = O(2 n ) Zur Erinnerung: Die Säule im Tempel von Hanoi bestand aus 64 Scheiben. Die Prophezeiung besagte, dass nach dem Versetzen der Säule das Ende der Welt bevorstehe

22 4.4 Problemkomplexität Komplexität des Problems P ist Ω(g) bedeutet: jeder Lösungsalgorithmus für P hat Komplexität Ω(g) Beispiel: Maximumsuche in unsortierter Folge: Ω(n) Denn jeder denkbare (sequentielle!) Algorithmus hat Komplexität Ω(n). Algorithmus mit O(f) für Problem mit Ω(g) heißt optimal, wenn f = g. Beispiel: Maximumsuche ist optimal, wenn T(n) = O(n)