Laufzeit und Komplexität

Laufzeit und Komplexität Laufzeit eines Algorithmus Benchmarking versus Analyse Abstraktion Rechenzeit, Anzahl Schritte Bester, Mittlerer, Schlechtester Fall Beispiel: Lineare Suche Komplexitätsklassen und O-Notation Problemgröße Vernachlässigung nicht relevanter Teile, O-Notation Wichtige Komplexitätsklassen und typische Laufzeiten Laufzeitanalyse von Algorithmen Beispiele: Binäre und lineare Suche Medieninformatik Algorithmen und Datenstrukturen 1

Motivation Suchen Wie schnell kann man suchen? Medieninformatik Algorithmen und Datenstrukturen 2

Suche in einem Feld Ein Feld (Array) a Mit n Elementen im Beispiel n=10 Indiziert von 0 bis n-1 im Beispiel 0 bis 9 Aufsteigend sortiert für alle 0 pos n-1: a[pos] a[pos+1] Problemstellung Suche ein vorgegebenes Element s in a Bestimme Index pos, so dass a[pos] gleich s und gebe pos zurück Falls s nicht in dem Feld gebe n zurück a s Problem: Suche in einem Feld Eingabe: Feld a mit n Elementen Suchwert s Ausgabe: pos falls ein pos existiert mit a[pos] gleich s n sonst 2 3 5 7 11 13 17 19 23 29 42 0 1 2 3 4 5 6 7 8 9 Nicht enthalten, Rückgabe 10 Medieninformatik Algorithmen und Datenstrukturen 3

Lineare Suche Lineare Suche Idee Teste sequentiell (hintereinander) von links nach rechts alle Feldelemente auf Gleichheit mit Suchwert Sobald gefunden breche ab a ==? 2 3 5 7 11 13 17 19 23 29 0 1 2 3 4 5 6 7 8 9 s 42 Lineare Suche Algorithmus Initialisiere Indexvariable (Position) pos mit 0 Durchlaufe eine Schleife Falls pos ein korrekter Index ist (innerhalb der Feldgrenzen) und das Element noch nicht gefunden wurde Erhöhe pos um 1 Gebe pos zurück # Lineare Suche pos = 0 while pos < n and a[pos]!= s: pos = pos+1 return pos Medieninformatik Algorithmen und Datenstrukturen 4

Laufzeitbetrachtung mit Anzahl Schritten Benchmarking nicht aussagekräftig Implementieren des Algorithmus in spezifischer Programmiersprache Testen mit verschiedenen Eingaben Probleme Abhängig von Hardware, Sprache, Compiler, Implementierungsdetails, Testauswahl Ausführen auf doppelt so schnellem Rechner macht Algorithmus nicht besser/effizienter Besser: Anzahl der Einzelschritte Einzelschritt als abstrakte Zeiteinheit Bestimmung der Anzahl der Einzelschritte Unabhängig von Hardware, Implementierungsdetails (Sprache, Compiler) Probleme, z.b. Testauswahl Im Beispiel ist Element nicht im Feld, also werden alle Elemente getestet Was passiert, wenn das Element im Feld ist? Medieninformatik Algorithmen und Datenstrukturen 5

Laufzeitbetrachtung Lineare Suche Analyse Schritte konkretes Beispiel Zuweisung 10 Schleifendurchläufe a 4 Einzelschritte Zwei Tests Feldzugriff Addition Letzter Test Rückgabe Anzahl Schritte 1 + 10 4 + 2 = 43 Schritte a s 2 3 5 7 11 13 17 19 23 29 42 0 1 2 3 4 5 6 7 8 9 # Lineare Suche pos = 0 while pos < n and a[pos]!= s: pos = pos+1 return pos Medieninformatik Algorithmen und Datenstrukturen 6

Abstraktionen für die Laufzeitbetrachtung Abstraktion vom Rechner und der konkreten Implementierung Berechnen der Anzahl der Einzelschritte Basierend auf abstrakter Maschine, möglichst nahe an realer Hardware für Realisierung Einzelschritt Definition eines Einzelschritts zum Beispiel Zuweisung, Addition, Vergleich,... Abstraktion von konkreten Problemen Allgemeine Beschreibung der Eingabeobjekte statt konkrete Werte Festlegung der Größe der Eingabeobjekte, zum Beispiel Feldgröße n Aussagen über besten, mittleren, schlechtesten Fall zum Beispiel Element gefunden, Element nicht gefunden Aussagen für große n, Vernachlässigung von Bestandteilen die unabhängig von n sind Medieninformatik Algorithmen und Datenstrukturen 7

Größe der Eingabeobjekte Abstraktion von konkreter Menge an möglichen Eingabeobjekten Das Wesentliche ist meist die Größe Kein einheitliches Maß möglich ein irgendwie hergeleitetes n Meist in Zusammenhang mit Problemstellung Beispiele Feldgröße n (oder Anzahl der Elemente) für Suchen und Sortieren Gleichungssysteme mit m Gleichungen und k Unbekannten, für n kann m k gewählt werden, die Anzahl der Koeffizienten Graphen, für n zum Beispiel Anzahl der Knoten oder Anzahl der Kanten... Medieninformatik Algorithmen und Datenstrukturen 8

Bester, mittlerer, schlechtester Fall Bester Fall Konstruktion einer spezifischen Eingabe Mit der minimal möglichen Anzahl von Schritten Meist nicht charakteristische Aussage Mittlerer Fall Bei allen möglichen Eingaben, (oder mit Nebenbedingungen auf relevante Eingaben beschränkt) Durchschnittliche Anzahl von Schritten über alle diese Eingaben Interessante und schwierigste Aussage Schlechtester Fall Konstruktion einer spezifischen Eingabe Mit der maximal möglichen Anzahl von Schritten Relevante und meist machbare Aussage Medieninformatik Algorithmen und Datenstrukturen 9

Lineare Suche Bester Fall Eingabe s = a[0] Analyse Zuweisung Schleife einmal mit Vergleich Feldzugriff Vergleich Rückgabe Anzahl Schritte 1 + 3 + 1 = 2 + 3 = 5 Schritte Bester Fall Immer 5 Schritte Unabhängig von Feldgröße a s 2 3 5 7 11 13 17 19 23 29 2 0 1 2 3 4 5 6 7 8 9 # Lineare Suche pos = 0 while pos < n and a[pos]!= s: pos = pos+1 return pos Medieninformatik Algorithmen und Datenstrukturen 10

Lineare Suche Schlechtester Fall Eingabe s nicht im Feld s a[pos] für alle 0 Analyse Zuweisung Schleife n-mal mit Vergleich Feldzugriff Vergleich Addition Letzter Vergleich Rückgabe Anzahl Schritte pos < n 1 + 4 n + 2 = 3 + 4 n Schritte Schlechtester Fall Immer 3+4 n Schritte a s 2 3 5 7 11 13 17 19 23 29 42 0 1 2 3 4 5 6 7 8 9 # Lineare Suche pos = 0 while pos < n and a[pos]!= s: pos = pos+1 return pos Medieninformatik Algorithmen und Datenstrukturen 11

Lineare Suche Mittlerer Fall Eingabe Annahme über Verteilung der Eingabeobjekte muss gemacht werden Position von s im Feld, sowie s nicht im Feld, sind gleichverteilt Analyse Falls s an der Position pos für 0 pos < n: Laufzeit = 2+4 pos + 3 = 5 + 4 pos Falls s nicht enthalten: Laufzeit 3 + 4n Vereinfachende Annahme (Feld eins länger, s in a[n]): Laufzeit 5+4n Laufzeit im Mittel ist (bei Gleichverteilung) Summe Laufzeiten für 0 pos n (inklusive nicht enthalten) geteilt durch n+1 Dies entspricht 5 + 2 n, Herleitung nächste Seite Anzahl Schritte: 5 + 2 n Schritte Mittlerer Fall Im Schnitt 5 + 2 n Schritte Ungefähr halb so viel wie im schlechtesten Fall (entspricht Intuition) Medieninformatik Algorithmen und Datenstrukturen 12

Herleitung Mittlerer Fall Summe der möglichen Laufzeiten durch Anzahl mögliche Laufzeiten n i=0 5 4 i n 1 Konstanten rausziehen Summe aufspalten n i=0 5 n 1 4 i=0 n 1 n i Summen auflösen Gauß (Induktionsbeweis) 5 n 1 n 1 4 n n 1 2 n 1 Vereinfachen 5 4 n n 1 2 n 1 Vereinfachen 5 2 n Medieninformatik Algorithmen und Datenstrukturen 13

Aussagen über Algorithmenlaufzeit Man sucht nach relativen Aussagen über Skalierbarkeit Bei Verdopplung der Eingabegröße braucht der Algorithmus doppelt so lang Interessant ist Relative Lage Für große n Beispiel Schlechteste Laufzeit bei linearer Suche 3+4n Vernachlässigen kleinerer Funktionsteile 4n Vernachlässigen von Konstanten n Aussage Bei Verdopplung von n doppelt so lange Medieninformatik Algorithmen und Datenstrukturen 14

Vernachlässigen kleiner Funktionsteile Vernachlässigen kleiner Funktionsteile Idee Aussagen von Laufzeitfunktion für große n Konzentration auf den am stärksten wachsenden Teil der Funktion Beispiel: 4n statt 3 + 4n Für kleine n ist der Unterschied zwischen 3 + 4n und 4n relativ groß Bei n = 2 ist die Abweichung rund 20 Prozent Aber bei ~ 1 Million Schritte pro Sekunde liegt der Fehler im Mikrosekundenbereich Für große n ist der Fehler relativ zu der Zahl minimal Schon bei n = 10,000 ist der Fehler kleiner als ein Hundertstel eines Prozents und die Gesamtlaufzeit noch kleiner als eine Sekunde Je größer n, desto geringer der Fehler 3+4n 4n Medieninformatik Algorithmen und Datenstrukturen 15

Vernachlässigen von Konstanten Vernachlässigen von Konstanten Aussagen von Laufzeitfunktionen unabhängig von Hardware Konstante Faktoren repräsentieren Dauer eines Schritts Ignorieren von konstanten Faktoren Beispiel: n statt 4n Der Unterschied zwischen 4n und n ist ein konstanter Faktor Aussagen wie Bei Verdopplung der Eingabegröße braucht der Algorithmus doppelt so lange werden dadurch nicht beeinträchtigt Konstante Faktoren sind typischerweise abhängig von weg abstrahierten Eigenschaften n statt 4n könnte durch 4 mal schneller Maschine erreicht werden Annahme, dass Einzelschritt nur ein Viertel Zeiteinheit braucht 4n n Medieninformatik Algorithmen und Datenstrukturen 16

Zuordnung von Klassen zu Funktionen Idee Gruppieren von Funktionen Vernachlässigen und Reduktion aufs Wesentliche Wenn zwei Funktionen nach Vernachlässigung und Reduktion identisch sind, dann gehören Sie zu der gleichen Klasse Namen für die wichtigsten Klassen Formal O-Notation (asymptotisch obere Schranken) Beispiel: Lineare Suche Laufzeitfunktion T(n) = 2 + 4 n Vernachlässigung: 2 + 4 n 4 n n, T(n) ist linear 66 + 42 n ist auch linear Weitere Beispiele 3 + 4 n + 5 n² 5 n² n² quadratisch 987 + 98 n + 3 n³ 3 n³ n³ kubisch 34 + 4 log n 4 log n log n logarithmisch 987 + 98 n 98765 + 3 2 n 3 2 n 2 n exponentiell Medieninformatik Algorithmen und Datenstrukturen 17

O-Notation T O(g) T wächst nicht schneller als g g ist eine asymptotische obere Schranke von T Ab einem bestimmten n wächst g schneller als T Ab einem bestimmten n ist für ein bestimmtes c der Wert c g(n) immer größer als T(n) Formale Spezifikation T O(g) Es existiert eine Konstante c 0 eine Konstante n 0 0 so dass für alle n n 0 gilt, dass T(n) c g(n) n 0 c g(n) T(n) c 0 n 0 0 n n 0 : T n c g n Medieninformatik Algorithmen und Datenstrukturen 18

O-Notation Andere Symbole Alternative Schreibweise: T = O(g) Eigentlich T O(g), aber = Notation hat sich eingebürgert Sprechweise bleibt, T ist in O von g Notationsproblem Achtung bei Gleichungsketten: Gleichheit gilt nicht!!! g = (T) genau dann wenn T = O(g) g wächst mindestens so schnell wie T T = (g) genau dann wenn T = O(g) und g = O(T) T und g sind von der gleichen Wachstumsordnung Sinnvoll für gute Abschätzungen Medieninformatik Algorithmen und Datenstrukturen 19

Rechnen mit der O-Notation Zugehörigkeit zu Komplexitätsklassen f = O(f) O(O(f)) = O(f) Ignorieren von Konstanten möglich, für c Konstante c O(f) = O(f) O(c f) = O(f) O(f+c) = O(f) Addition (Maximum) O(f) + O(g) = O(max(f,g)) O(c 0 + c 1 n + c 2 n 2 +... + c k n k ) = O(n k ) Multiplikation (bleibt Multiplikation) O(f) O(g) = O(f g) Es gilt O(1) < O(log(n)) < O (n) < O (n log(n)) < O(n 2 ) <... < O(2 n ) Medieninformatik Algorithmen und Datenstrukturen 20

Einfluss auf die Analyse Initialisierung Ignorieren von Konstanten Einfache Initialisierung und Aufräumen kann ignoriert werden f und h nicht von n abhängig, das heißt konstant Beispiel Lineare Suche Initialisierung i = 0 ignorieren Rückgabe ignorieren // Algorithmus A, Konstanten f g(n) h O(A) = O(f) + O(g) + O(h) = O(g) # Lineare Suche i = 0 while i < n and a[i]!= s: i = i+1 return i Medieninformatik Algorithmen und Datenstrukturen 21

Einfluss auf die Analyse Sequenz, Verzweigung Verzweigung und Sequenz Addition der Teile entspricht Maximum Sequenz Bei hintereinander ausgeführten Algorithmenteilen wird der einfachere vernachlässigt Verzweigung Abschätzung nach oben, Maximum der beiden Verzweigungsmöglichkeiten // Algorithmus A, Sequenz f g O(A) = O(f) + O(g) = O(max(f,g)) // Algorithmus B, Verzweigung if t: f else: g h O(B) = O(t) + O(max(f,g)) + O(h) = O(max(t,f,g,h)) Medieninformatik Algorithmen und Datenstrukturen 22

Sequenz, Verzweigung in Linearer Suche Einmaliger Durchlauf der while-schleife Sequenz bei Durchlauf Schleife Bei hintereinander ausgeführten Algorithmenteilen wird der einfachere vernachlässigt Erster Vergleich, dann Feldzugriff, dann zweiter Vergleich, dann Addition Alles konstant (O(1)), also gesamt konstant Verzweigung bei Abbruch Schleife Maximum der beiden Verzweigungsmöglichkeiten Entweder erster Test klappt nicht, oder zweiter Test klappt nicht Alles konstant, also gesamt konstant Einmaliger Durchlauf while-schleife ist O(1) # Lineare Suche i = 0 while i < n and a[i]!= s: i = i+1 return i Medieninformatik Algorithmen und Datenstrukturen 23

Einfluss auf die Analyse Schleife Schleife ist Multiplikation Häufigkeit in Abhängigkeit von n in der Schleifenkörper durchlaufen wird Multiplizieren mit dieser Häufigkeit Annahme: O(t) O(f) // Algorithmus A, Schleife while t: f O(A) = O(f) Anzahl Durchläufe in Abhängigkeit von n For-Schleife n-maliges Durchlaufen Mit n multiplizieren Beispiel n-maliges Durchlaufen (for Schleife) Linearer Algorithmus f n O(n) = O(n) O(n) = O(n²) // Algorithmus A, for-schleife for i in 1..n: f O(A) = O(f) n Medieninformatik Algorithmen und Datenstrukturen 24

Schleife in Linearer Suche Anzahl der Durchläufe Im besten Fall 1 mal (O(1)) Im schlechtesten Fall n mal (O(n)) Im mittleren Fall n/2 mal (O(n)) Anzahl Durchläufe O(n) Zusammengefasst Schleifenkörper O(1) Anzahl Durchläufe O(n) Initialisierung und Ende O(1) Gesamt: O(n) # Lineare Suche i = 0 while i < n and a[i]!= s: i = i+1 return i Medieninformatik Algorithmen und Datenstrukturen 25

O statt T Laufzeit T(n) T ist Funktion, die die Anzahl der Elementarschritte eines Algorithmus in Abhängigkeit der Eingabegröße n berechnet Genau für konkrete Laufzeit Schwierig zu berechnen (viel Fallunterscheidung) Nicht direkt aussagekräftig für Skalierungsaussagen Komplexität O(T(n)) Zuordnung einer Laufzeitfunktion T zu einer Klasse von Funktionen Ungenau für konkrete Laufzeit Viel leichter zu berechnen Sofort aussagekräftig für relevante Skalierungsaussagen Aussagen über Effizienz von Algorithmen Angabe von O(T(n)), asymptotische obere Grenze Meist Angabe von f mit T(n) = (f), gleiches Wachstum Medieninformatik Algorithmen und Datenstrukturen 26

Bezeichnungen O(1): konstant O(log i (n)): logarithmisch (Basis i egal) O(n): linear O(n log i (n)): keine Bezeichnung, trotzdem sehr wichtig! O(n²): quadratisch O(n³): kubisch O(nk ): polynomiell (bzw. polynomiell begrenzt), beliebiges k O(2n ): exponentiell Medieninformatik Algorithmen und Datenstrukturen 27

Typische Laufzeiten polynomiell exponentiell Logarithmisch, linear und n log(n) sind gut handhabbar Höhergradig polynomiell meist machbar Exponentiell ist massiv unangenehm Grenze des praktisch Lösbaren Medieninformatik Algorithmen und Datenstrukturen 28

Typische Beispiele in den Klassen O(1): Feldzugriff, Hashing O(log i (n)): Binäre Suche O(n): Lineare Suche O(n log i (n)): Sortieren schnell O(n²): Sortieren langsam, kürzeste Wege O(nk ): Simplex (Praxis) O(2n ): Simplex (Theorie), Aussagenlogik, Ganzzahlige Optimierung Medieninformatik Algorithmen und Datenstrukturen 29

Kritik O-Notation und vorgestellte Herangehensweise Grobe Abschätzung Gute Informationen für schlechtesten Fall und große Probleme (Skalierung) Praxis Konstanter Faktor nicht berücksichtigt. Wichtig für Benutzerinteraktion ob 0,2 oder 2 Sekunden Wartezeit Wenn Problemgröße beschränkt ist, kann ein laut O-Notation schlechteres Verfahren besser sein Spezielle Hardware wird nicht berücksichtigt (nur implizit Beispiel: Termauswertung als Elementaroperation) Mittelwert kann wichtiger sein (Beispiel Simplex) Mitdenken nicht vergessen! (Gilt öfter ;-) Medieninformatik Algorithmen und Datenstrukturen 30

Komplexität Problem/Algorithmus Nicht verwechseln! Verschiedene Lösungsalgorithmen für ein Problem möglich Komplexität eines Problems Zugehörigkeit zur Komplexitätsklasse der Laufzeit des besten Algorithmus Beispiel: Suche in sortiertem Feld, Komplexität O(log(n)) Komplexität eines Algorithmus Zugehörigkeit Komplexitätsklasse der Laufzeit dieses Algorithmus Beispiel: Suche in sortierten Feld mit linearer Suche, Komplexität O(n) Komplexität eines Problems schwierig zu bestimmen Komplexität einer Problemklasse schwierig zu bestimmen Bekanntestes Beispiel: P NP Beweis steht noch aus!! P Klasse Polynomieller Probleme NP Klasse Nichtdeterministisch Polynomieller Probleme (nur exponentielle Algorithmen zur Lösung bisher bekannt) Medieninformatik Algorithmen und Datenstrukturen 31

Suchen Lineare Suche Suchen Problemgröße: n, Anzahl der Feldelemente Komplexität: O(n) Beste: O(1) Mittlere: O(n) Schlechteste: O(n) Keine Voraussetzungen an Liste Suchen in sortierter Liste Wenn Liste sortiert, dann geht es besser... a s 2 3 5 7 11 13 17 19 23 29 42 0 1 2 3 4 5 6 7 8 9 # Lineare Suche pos = 0 while pos < n and a[pos]!= s: pos = pos+1 return pos Medieninformatik Algorithmen und Datenstrukturen 32

Suchen in Sortierter Liste Binäre Suche Suchen in sortierter Liste Problemgröße: n, Anzahl der Feldelemente Komplexität: O(log n) Beste: O(1) Mittlere: O(log n) Schlechteste: O(log n) Liste muss sortiert sein 0 i n 1 :a[i] a[i 1] Suche in sortierten und unsortierten Feldern sind zwei unterschiedliche Probleme a s 2 3 5 7 11 13 17 19 23 29 42 0 1 2 3 4 5 6 7 8 9 # Binäre Suche li = 0 re = n-1 while re >= li: x = (li+re)/2 if s == a[x]: return x if s < a[x]: re = x-1 else: li = x+1 return n Medieninformatik Algorithmen und Datenstrukturen 33

Binäre Suche Beispiel Halbiere den Suchbereich Bis gefunden oder Suchbereich leer a s 2 3 5 7 11 13 17 19 23 29 18 0 1 2 3 4 5 6 7 8 9 # Binäre Suche li = 0 re = n-1 while re >= l: x = (li+re)/2 if s == a[x]: return x if s < a[x]: re = x-1 else: li = x+1 return n li=0 li=5 li=5 re=6 li=re= 6 re=6 li=7 nicht gefunden re=9 re=9 Medieninformatik Algorithmen und Datenstrukturen 34

Binäre Suche Rekursiv Rekursiver Algorithmus bs_rek Aufruf mit bs_rek(0, n-1) Reduktion auf Teilfeld, halbiere Problemgröße Suche in Teilfeld, Löse halb so großes Problem Terminierung wenn Teilfeld leer oder gefunden, Problem trivial Typische Rekursion Löse Problem durch Problemreduktion Lösen des kleineren Problems durch rekursiven Aufruf Abfangen trivialer Fall Keine explizite Schleife mehr # Binäre Suche rekursiv # a, n vorhanden def bs_rek(li, re): if re < li: return n x = (li+re)/2 if s == a[x]: return x if s < a[x]: return bs_rek(li, x-1) else return bs_rek(x+1, re) Medieninformatik Algorithmen und Datenstrukturen 35

Analyse der Binären Suche Betrachtung schlechtester Fall Element nicht gefunden Schleife wird beendet wenn li und re sich treffen Wenn li und re sich treffen noch genau ein Durchlauf (konstant, ignoriert) Bei jedem Durchlauf wird Abstand von l und r halbiert Initial ist der Abstand n Beim zweiten Durchlauf n/2 Beim dritten Durchlauf n/4... Schleife wird log(n) mal durchlaufen, O(log(n)) [formal folgt] Anweisungen innerhalb Schleife konstant Anweisungen sind unabhängig von n, also konstant Einfluss Anweisungen wird ignoriert, O(1) Komplexität Binäre Suche: O(log(n)) Medieninformatik Algorithmen und Datenstrukturen 36

Analyse Binäre Suche Rekurrenz Laufzeit der binären Suche Was ist T(n)? Rekursiver Aufruf Halb so großes Problem T(n/2) Anweisungen in Funktion Unabhängig von n Konstant c, O(1) Es gilt also T(n) = T(n/2) + c # Binäre Suche rekursiv # a, n vorhanden def bs_rek(li, re): if re < li: return n x = (li+re)/2 if s == a[x]: return x if s < a[x]: return bs_rek(li, x-1) else return bs_rek(x+1, re) eine Rekurrenz-Beziehung Medieninformatik Algorithmen und Datenstrukturen 37

Auflösen der Rekurrenz Lösen der Rekurrenz: T(n) = T(n/2) + c Annahme: T(1) konstant d, n = 2 k T(2 k ) = T(2 k-1 ) + c = T(2 k-2 ) + c + c = T(2 k-3 ) + c + c + c... = T(2 k-k ) + k c = d+ k c T(2 k ) ~ k Es gilt log 2 (2 k ) = k, Anzahl Ziffern Binärdarstellung Also ist Laufzeit für diesen Fall logarithmisch Beliebige n, obere Abschätzung mit nächster Zweierpotenz Verlängern des Feldes auf das nächste 2 k, 2 k-1 < n 2 k T(n) O(log 2 (n)) da T(2 k-1 ) = T(2 k-2 ) + c da T(2 k-2 ) = T(2 k-3 ) + c Medieninformatik Algorithmen und Datenstrukturen 38