Effizienz
(Vorlesung 7.5.:)
Laufzeit
Die Laufzeit ist für den Benutzer ein wichtiges Kriterium. Schwierigkeit bei der Bestimmung: Die Laufzeit hängt von vielen Faktoren ab die evtl. nicht kontrollierbar sind:
- Prozessor/Auslastung des Systems
- Speicher/Cache/Bus
- Compiler/Optimierer des Compilers (Compiler auf verschiedene Architekturen optimiert?)
- Geschick des Programmierers
- Daten (Beispiel Quicksort: Best case und worst case[Vorsortierter Input] stark unterschiedlich)
All diese Faktoren sind untereinander abhängig.
Laufzeitvergleiche sind mit Vorsicht zu interpretieren. Generell sollten bei Vergleichen möglichst wenige Parameter verändert werden, z.B.
- gleiches Programm(gleiche Kompilierung), gleiche Daten, andere Prozessoren
oder
- gleiche CPU, Daten, andere Programme (Vergleich von Algorithmen)
Beobachtung: Durch Laufzeitmessung ist schwer festzustellen, ob ein Alg prinzipiell besser ist als ein anderer.
Komplexität
Komplexitätsbetrachtungen ermöglichen den Vergleich der prinzipiellen Eigenschaften von Algorithmen unabhängig von einer Implementation, Umgebung etc.
Eine einfache Möglichkeit ist das Zählen der Aufrufe einer Schlüsseloperation. Beispiel Sortieren:
- Anzahl der Vergleiche
- Anzahl der Vertauschungen
Beispiel: Selection Sort
for i in range(len(a)-1): max = i for j in range(i+1, len(a)): if a[j] < a[max]: max = j a[max], a[i] = a[i], a[max] # swap
- Anzahl der Vergleiche: Ein Vergleich in jedem Durchlauf der inneren Schleife. Es ergibt sich folgende Komplexität:
- Ingesamt <math>\sum_{i=0}^{N-2} \sum_{j=i+1}^{N-1}1 = \frac{N}{2} (N-1) \!</math> Vergleiche.
- Anzahl der Vertauschungen: Eine Vertauschung pro Durchlauf der äußeren Schleife:
- Insgesamt <math>N-1 \!</math> Vertauschungen
Die Komplexität wird durch die Operationen bestimmt, die am häufigsten ausgeführt werden, hier also die Anzahl der Vergleiche. Die Anzahl der Vertauschungen ist kein geeignetes Kriterium für die Komplexität von selection sort, weil der Aufwand in der inneren Schleife ignoriert wird.
Fallunterscheidung: Worst und Average Case
Die Komplexität ist in der Regel eine Funktion der Eingabegröße (Anzahl der Eingabebits, Anzahl der Eingabeelemente). Sie kann aber auch von der Art der Daten abhängen, nicht nur von der Menge, z.B. vorsortierte Daten bei Quicksort. Um von der Art der Daten unabhängig zu werden, kann man zwei Fälle der Komplexität unterscheiden:
- Komplexität im ungünstigsten Fall
- Der ungünstigste Fall ist die Eingabe gegebener Länge, für die der Algorithmus am langsamsten ist. Der Nachteil dieser Methode besteht darin, dass dieser ungünstige Fall in der Praxis vielleicht gar nicht oder nur selten vorkommt, so dass sich der Algorithmus in Wirklichkeit besser verhält als man nach dieser Analyse erwarten würde. Beim Quicksort-Algorithmus mit zufälliger Wahl des Pivot-Elements müsste z.B. stets das kleinste oder größte Element des aktuellen Intervalls als Pivot-Element gewählt werden, was äußerst unwahrscheinlich ist.
- Komplexität im durchschnittlichen/typischen Fall
- Der typische Fall ist die mittlere Komplexität des Algorithmus über alle möglichen Eingaben. Dazu muss man die Wahrscheinlichkeit jeder möglichen Eingabe kennen, und berechnet dann die mittlere Laufzeit über dieser Wahrscheinlichleitsverteilung. Leider ist die Wahrscheinlichkeit der Eingaben oft nicht bekannt, so dass man geeignete Annahmen treffen muss. Bei Sortieralgorithmen können z.B. alle möglichen Permutationen des Eingabearrays als gleich wahrscheinlich angenommen werden, und der typische Fall ist dann die mittlere Komplexität über alle diese Eingaben. Oft hat man jedoch in der Praxis andere Wahrscheinlichkeitsverteilungen, z.B. sind die Daten oft "fast sortiert" (nur wenige Elemente sind an der falschen Stelle). Dann verhält sich der Algorithmus ebenfalls anders als vorhergesagt.
Wir beschränken uns in dieser Vorlesung auf die Komplexität im ungünstigseten Fall. Exakte Formeln für Komplexität sind aber auch dann schwer zu gewinnen, wie das folgende Beispiel zeigt:
Beispiele aus den Übungen (Gemessene Laufzeiten für Mergesort/Selectionsort)
- Mergesort: <math>\frac{0,977N\log N}{\log 2} + 0,267N-4.39 \!</math>
- andere Lösung: <math>1140 N\log(N) - 1819N + 6413 \!</math>
- Selectionsort: <math>\frac{1}{2}N^2 - \frac{1}{2N} - 10^{-12} \!</math>
- andere Lösung: <math>1275N^2 - 116003^N + 11111144 \!</math>
Aus diesen Formeln wird nicht offensichtlich, welcher Algorithmus besser ist. Näherung: Betrachte nur sehr große Eingaben (Meist sind alle Algorithmen schnell genug für kleine Eingaben). Dieses Vorgehen wird als Asymptotische Komplexität bezeichnet (N gegen unendlich).
Asymptotische Komplexität am Beispiel Polynom
Polynom: <math>ax^2+bx+c=p\!</math>
<math>x \!</math> sei die Eingabegröße, und wir betrachten die Entwicklung von <math>p \!</math> in Abhängigkeit von <math>x \!</math>.
- <math>x=0 \!</math>
- <math>p=c \!</math>
- <math>x=1 \!</math>
- <math>p=a+b+c \!</math>
- <math>x=1000 \!</math>
- <math>p=1000000a+1000b+c \approx 1000000a\!</math>
- <math>x \to \infty \!</math>
- <math>p \approx x^2a\!</math>
Für sehr große Eingaben verlieren also b und c immer mehr an Bedeutung, so dass am Ende nur noch a für die Komplexitätsbetrachtung wichtig ist.
O-Notation
- Intuitiv: Für große N dominieren die am schnellsten wachsenden Terme.
- Formale Definition:
- Asymptotische Komplexität: Für zwei Funktionen f(x) und g(x) definiert man
- <math>f(x) \in \mathcal{O}(g(x))</math>
- (sprich "f ist in \mathcal{O}(g)" oder "f ist von derselben Größenordnung wie g") genau dann wenn es eine Konstante <math>c</math> und ein Argument <math>x_0</math> gibt, so dass
- <math>\forall x > x_0:\quad f(x) \le c g(x)</math>.
- Die Idee hinter dieser Definition ist, dass g(x) eine wesentlich einfachere Funktion ist als f(x), die sich aber nach geeigneter Skalierung (Multiplikation mit c) und für große Argumente x im wesentlichen genauso wie f(x) verhält. Man kann deshalb in der Algorithmenanalyse f(x) durch g(x) ersetzen. <math>f(x) \in \mathcal{O}(g(x))</math> spielt für Funktionen eine ähnliche Rolle wie der Operator ≤ für Zahlen: Falls a ≤ b gilt, kann bei einer Abschätzung von oben ebenfalls a durch b ersetzt werden.
- Asymptotische Komplexität: Für zwei Funktionen f(x) und g(x) definiert man
Ein einfaches Beispiel
Rot = <math>x^2 \!</math> Blau = <math>\sqrt{x} \!</math>
<math>\sqrt{x} \in \mathcal{O}(x^2)\!</math> weil <math>\sqrt{x} \le c x^2\!</math> für alle <math>x < x_0 = 1 \!</math> und <math>c = 1\!</math>, oder auch für <math>x < x_0 = 4 \!</math> und <math>c = 1/16</math> (die Wahl von c und x0 in der Definition von O(.) ist beliebig, solange die Bedingungen erfüllt sind).
Komplexität bei kleinen Eingaben
Algorithmus 1: <math>\mathcal{O}(N^2) \!</math> Algortihmus 2: <math>=\mathcal{O}(N\log{N}) \!</math>
Algorithmus 2 ist schneller (Von geringerer Komplexität), aber bei vielen wiederholten kleinen Eingaben ist Algorithmus 1 schneller.
Eigenschaften der O-Notation(Rechenregeln)
- Transitiv:
- <math>f(x) \in \mathcal{O}(g(x)) \land g(x) \in \mathcal{O}(h(x)) \to f(x) \in \mathcal{O}(h(x)) \!</math>
- Additiv:
- <math>f(x) \in \mathcal{O}(h(x)) \land g(x) \in \mathcal{O}(h(x)) \to f(x) + g(x) \in \mathcal{O}(h(x)) \!</math>
- Für Monome gilt:
- <math>x^k \in \mathcal{O}(x^k)) \land x^k \in \mathcal{O}(x^{k+j}), \forall j \ge 0 \!</math>
- Multiplikation mit einer Konstanten:
- <math>f(x) \in \mathcal{O}(g(x)) \to cf(x) \in \mathcal{O}(g(x))\!</math>
- andere Schreibweise:
- <math>f(x) = cg(x) \to f(x) \in \mathcal{O}(g(x))\!</math>
- Beispiel: <math>ax^2+bx+c \in \mathcal{O}(x^2)\!</math>
- Folgerung für Polynome: <math>a_0+a_1x + ... + a_nx^n \in \mathcal{O}(x^n)\!</math>
- Logarithmus:
- <math>a, b \neq 1\!</math>
- <math>\log_{a}{x} \in \mathcal{O}(\log_{b}{x})\!</math>
- Die Basis des Logarithmus spielt also keine Rolle.
- Beweis hierfür:
- <math>\log_{a}{x} = \frac{\log_{b}{x}}{\log_{b}{a}}\!</math>
- <math>c = \log_{b}{a}\!</math>
- <math>c\log_{a}{x} = \log_{b}{x}\!</math>, wird hier die Regel für Multiplikation mit einer Konstanten angewendet fällt der Konstante Faktor weg.
- Insbesondere gilt auch <math>\log_{a}{x} \in \mathcal{O}(\log_{2}{x})\!</math>, es kann also immer der 2er Logarithmus verewendet werden.
O-Kalkül
- <math>f(x) \in \mathcal{O}(f(x))\!</math>
- <math>\mathcal{O}(\mathcal{O}(f(x))) \in \mathcal{O}(f(x))\!</math>
- <math>k\mathcal{O}(f(x)) \in \mathcal{O}(f(x))\!</math>
- <math>\mathcal{O}(f(x))+c \in \mathcal{O}(f(x))\!</math>
- Sequenzregel:
- <math>g(x) \in \mathcal{O}(f(x)) \to \mathcal{O}(f(x)) + \mathcal{O}(g(x)) \in \mathcal{O}(f(x))\!</math>, oder <math>f(x) \in \mathcal{O}(g(x)) \to \mathcal{O}(f(x)) + \mathcal{O}(g(x)) \in \mathcal{O}(g(x))\!</math>
- Informale Schreibweise: <math>\mathcal{O}(max(f(x), (g(x))\!</math>
- Aufruf, Verschachtelungsregel:
- <math>\mathcal{O}(f(x)) * \mathcal{O}(g(x)) \in \mathcal{O}(f(x) * g(x))\!</math>
O-Kalkül auf das Beispiel des Selectionsort angewandt
Selectionsort: <math>f(N) = \frac{N^2}{2} - \frac{N}{2} \in \mathcal{O}(\frac{N^2}{2}) \in \mathcal{O}(N^2)\!</math>
Oder via Multiplikationsregel: <math>\mathcal{O}(f(x))*\mathcal{O}(g(x)) \in \mathcal{O}(f(x)*g(x))\!</math>
- Äußere Schleife: <math>\mathcal{O}f(x)\!</math>
- <math>f(N) = N/2 = \mathcal{O}(N)\!</math>
- Innere Schleife: <math>\mathcal{O}g(x)\!</math>
- <math>g(N) = N-2 = \mathcal{O}(N)\!</math>
- <math>\mathcal{O}(f(N))*\mathcal{O}(g(N)) \in \mathcal{O}(f(x)*g(x))\!</math>
- <math>\mathcal{O}(N)*\mathcal{O}(N) \in \mathcal{O}(N*N) \in \mathcal{O}(N^2)\!</math>
Nach beiden Vorgehensweisen erreichen wir also den Schluss, dass der Selectionsort die asymptotische Komplexität <math>\mathcal{O}(N^2)\!</math> besitzt.
Zusammenhang zwischen Komplexität und Laufzeit
Wenn ein Rechenschritt 1ms dauert erreichen verschiedene komplexe Algorithmen folgende Leistungen
Komplexität | Operationen in 1s | Operationen in 1min | Operationen in 1h |
---|---|---|---|
<math>\mathcal{O}(N)</math> | 1000 | 60.000 | 3.600.000 |
<math>\mathcal{O}(n\log{N})</math> | 140 | 4895 | 204094 |
<math>\mathcal{O}(N^2)</math> | 31 | 244 | 1897 |
<math>\mathcal{O}(N^3)</math> | 10 | 39 | 153 |
<math>\mathcal{O}(2^N)</math> | 9 | 15 | 21 |
Exponentielle Komplexität
Der letzte Fall (<math>\mathcal{O}(2^N)</math>) ist von exponentieller Komplexität, das bedeutet eine Verdopplung des Aufwands bewirkt nur, dass die maximale Problemgröße um eine Konstante wächst. Algorithmen mit exponentieller Komplexität heißen ineffizient.
Dagegen bewirkt bei einer Komplexität von <math>\mathcal{O}(N^3)</math> ein verdoppelter Aufwand immer noch eine Steigerung der maximalen Problemgörße um den Faktor <math>\sqrt[3]{2}</math>.
(Vorlesung 8.5.)
(noch in Arbeit!!!)
Beispiel: running Average
Annahme: Array-Zugriff hat eine Komplexität von O(1)
Schritte | Version 1 O(N * k) | Komplexität | Version 2 O(N) | Komplexität |
---|---|---|---|---|
1. |
r = [0] * len(a) |
|
if k > len(a): |
|
2. |
if k > len(a): |
|
|
|
3. |
|
r = [0] * len(a) |
| |
4. |
for j in range(k, len(a)): |
|
for i in range(k): |
|
5. |
|
|
|
|
6. |
|
|
for j in range(k+1, len(a)): |
|
7. |
|
|
|
|
8. |
return r |
|
for j in range(len(a)): |
|
9. |
|
| ||
10. |
return r |
|
Trotz, dass Version 2 mehr Schritte benötigt besitzt das Programm eine geringere Komplexität.
Berechnung der Komplexität
Berechnung der Komplexität von Version 1
(Wiederholung der Rechenregeln:siehe Vorlesung 7.5.)
Zuweisungen
äußere Schleife = f(x)
innere Schleife = g(x)
4. Schritt: for j in range(k, len(a)) = äußere Schleife
- f(x) = O(N)(siehe Tabelle)
5. Schritt: for i in range(j-k+1, j+1) = innere Schleife
- g(x) = O(k)
- g(x) = O(k)
Multiplikationsregel ohne Konstante:
O(f(x) * O(g(x)) ∈ O(f(x) * g(x))
Multiplikationsregel angewendet auf Version 1
O(N) * O(k) ∈ O(N * k)
Komplexität von Version 1 = O(N * k)
Berechnung der Komplexität von Version2
siehe Tabelle
Zuweisungen
6.Schritt: for j in ange(k+1, len(a)):
- f1(x) = O(N)
8.Schritt: for j in range(len(a)):
- f2(x) = O(N)
4.Schritt: for i in range(k):
- g(x) = O(k)
Additionsregel:
O(f(x) + g(x)) = O(f(x))
falls g(x) ∈ O(f(x)) [O(max(f(x),g(x))]
O(f(x) + g(x)) ∈ O(g(x))
falls f(x) ∈ O(g(x)) [O(max(f(x),g(x))]
Anwendung der Additionsregel auf Version 2
O(f1(x)) + O(f2(x)) + O(g(x))
O(N) + O(N) +O(k) = O(N), falls O(k) ∈ O(N) [O(max(O(N),O(k]
(da wir wissen O(k) < O(N):
if k > len(a):
- raise RuntimeError("k zu groß")
- raise RuntimeError("k zu groß")
Daraus folgt:
→ k < len(a) → for-Schleifen die über k iterieren haben eine kleinere Komplexität als for-Schleifen die über len(a) iterieren)
Komplexität von Version 2 = O(N)
Fazit
Obwohl Version 2 mehr Schritte benötigt hat sie eine geringere Komplexität, da die for-Schleifen nicht wie bei Version 1 verschachtelt/untergeordnet sind. Bei verschachtelten for-Schleifen muss die Multiplikationsregel angewendet → höhere Komplexität
Die gerade berechnete Komplexität gilt nur unter der Annahme, dass Array-Zugriffe eine Komplexität von O(1) besitzen
Allgemein:
Algorithmen-Analysen beruhen auf der Annahme, dass Zugriff auf die Daten optimal schnell sind, dass heißt dass die geeigneteste Datenstruktur verwendetet wird. |
Beispiel für eine Verschlechterung der Komplexität durch Verwendung einer anderen Datenstruktur als die Optimalste
Beispiel: Verwende eine verkettete Liste anstatt einem Array
Verkettete Liste | Komplexität |
---|---|
L[j] |
|
|
O(1) |
while j > 0: |
|
|
O(1) |
|
O(1) |
gefunden: r.data |
O(1) |
<math> \Bigg\rbrace </math> O(j)
r[j] = r[j] + a[i] → O(1) → O(N), falls a[i]= O[N]
Folge:
Der Arrayzugriff einer verketteten Liste hat eine Komplexität von O(N).
Würden wir in unserem running Average-Beispiel(siehe oben) auf eine verkettete Liste zugreifen hätten wir anstatt O(1) eine Komplexität von O(N) für den Zugriff auf unser Array.
Beispiel: running-Average mit verketteter Liste
Schritte | Version 1 O(N * k) | Komplexität |
---|---|---|
1. |
verkettete Liste(siehe oben) |
|
2. |
if k > len(a): |
|
3. |
|
|
4. |
for j in range(k, len(a)): |
|
5. |
|
|
6. |
|
|
7. |
|
|
8. |
return r |
|
Amortisierte Komplexität
Bis jetzt wurde die Komplexität nur im schlechtesten Fall(Worst Case) betrachtet, die Komplexität im schlechtesten Fall schwankt jedoch.
Die amortisierte Komplexität beschäftigt sich mit der Komplexität im durschnittlichen/typischen Fall(Average Case)
Zum weiter Lesen: [Wikipedia: Amortisierte Laufzeitanalyse]
Beispiel: Inkrementieren von Binärzahlen
Frage: Was kostet eine Operation im Durchschnitt?
Annahme: Bei jeder Operation wird ein Gehalt vom Wert 1 bezahlt, dass dem Guthaben zugeschrieben wird, wenn die Kosten das Gehalt decken.
- Kosten <= Gehalt → es wird gespart
- Kosten > Gehalt → Guthaben - Gehalt werden für die Kosten verbraucht
Schritte | Zahlen | Kosten | Kosten + Sparen | Guthaben |
---|---|---|---|---|
1. | 00001 | 1 | 2 | 1 |
2. | 00010 | 2 | 2 | 1 |
3. | 00011 | 1 | 2 | 2 |
4. | 00100 | 3 | 2 | 1 |
Die Kosten ergeben sich aus der Anzahl der Ziffern die von 1 nach 0, bzw. von 0 nach 1 verändert werden
Rechnung:
1. Schritt: Kosten: 1 <= Gehalt: 1
- → es wird gespart
- → es wird gespart
2. Schritt: Kosten: 2 > Gehalt: 1
- → es wird nicht gespart
- → Guthaben: 1 - Gehalt: 1 = 0
- → Guthaben bleibt so wie es ist
- → es wird nicht gespart
3. Schritt: Kosten: 1 <= Gehalt: 1
- → → es wird gespart
- → → es wird gespart
4. Schritt: Kosten: 3 > Gehalt: 1
- → Guthaben: 2 - Gehalt: 1 = 1
- → es wird eine 1 vom Guthaben genommen um die Kosten zu zahlen
- → Guthaben: 2 - Gehalt: 1 = 1
Zum weiter Lesen: [Wikipedia Account-Methode]
statisches Array
Ein statisches Array hat eine feste Größe N und besitzt eine Komplexität von O(N).
Wird das Array um ein Element erweitert, muss ein neues Array mit der Größe N+1 erzeugt werden.
Anhängen eines weiteren Elements an ein statisches Array:
altesArray = [0,1,2,3]
altesArray.append('x')
1. Es wird ein neues Array der Größe N+1 erzeugt → neuesArray = [_,_,_,_,_] Komplexität: O(N+1) = O(N)
2. Die Daten aus dem alten Array werden in das neue Array mit der Länge N+1 kopiert → neuesArray = [0,1,2,3,_] Komplexität: O(N) (Die Operation besitzt nur eine Komplexität von O(N), wenn das Kopieren eines Elements eine Komplexität von O(1) besitzt)
3. 'x' wird an die letzte Stelle des neuen Arrays geschrieben → neuesArray = [0,1,2,3,'x'] Komplexität: O(1)
Additionsregel:
O(N) + O(N) + O(1) ∈ O(N), falls O(1) ∈ O(N) [O(max(O(N),O(1))] (Bedingung: N > 1)
dynamisches Array
Beim dynamischen Array werden mehr Speicherelemente reserviert als zur Zeit benötigt. Es gibt verschiedene Möglichkeiten wie ein dynamisches Array realisiert werden kann.
capacity = Anzahl der möglichen Elemente, die in das Array passen
size = Anzahl der Elemente, die im Array gespeichert sind
data = statisches Array der Größe "capacity"
A
Beispiele für mögliche Vorgehensweisen eines dynamischen Arrays beim Zufügen eines neuen Elements: (size == capacity)
- Ein neues statisches Array der Größe size == capacity wird erzeugt
- capacity wird verdoppelt
- → neue capacity = 2 * alte capacity
- capacity wird um einen Prozentsatz vergrößert
- &rarr neue capacity = alte capacity * c, c > 1
- ...
Folge: Das Hinzufügen eines neuen Elements in ein dynamisches Array ist amortisiert, die Operation besitzt eine Komplexität von O(1).
Analyse des dynamischen Arrays
Durchschnitt der Gesamtkosten für N-maliges append = <math>\frac{1}{N} \sum_{i = 1}^N Kosten(i)</math>
N-maliges append sind amortisierte Kosten, da size < capacity
Φ(t) = 2 * size - capacity
Fall 1: size < capacity
- → amortisierte Kosten, da kein Umkopieren nötig ist
Potential vor append: Φ(i-1) = 2(i-1) - capacity
Potential nach i-tem append: Φ (i) = 2(i) - capacity