03 O-Notation, Laufzeit und KomplexitÃƒÂ¤t - Medieninformatik

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 

Prof. Dr. Peter Barth 

Medieninformatik Algorithmen und Datenstrukturen 1

Motivation – Suchen 

● 

Wie schnell kann man suchen 



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 



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 



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 



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 


pos = 0 


pos = pos+1 

return pos 



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 



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 

– ... 



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 



Lineare Suche – Bester Fall 

● 

● 

● 

● 

Eingabe 

– s = a[0] 

Analyse 

– Zuweisung 

– Schleife einmal mit 

● Vergleich 


● Vergleich 

– Rückgabe 


– 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 


pos = 0 


pos = pos+1 

return pos 



Lineare Suche – Schlechtester Fall 

● 

● 

● 

● 

Eingabe 

– s nicht im Feld 

s ≠ a[pos] für alle 0 

Analyse 

– Zuweisung 

– Schleife n-mal mit 

● Vergleich 


● Vergleich 

● Addition 

– Letzter Vergleich 

– Rückgabe 


≤ 

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 


pos = 0 


pos = pos+1 

return pos 



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) 



Herleitung Mittlerer Fall 

Summe der möglichen Laufzeiten 

durch Anzahl mögliche Laufzeiten 

n 

∑ i=0 

54⋅i 

n1 

Konstanten rausziehen 

Summe aufspalten 

n 

∑ i=0 

5 

n1 4⋅ ∑ i=0 

n1 

n 

i 

Summen auflösen 

Gauß (Induktionsbeweis) 

5⋅n1 

n1 

4⋅ n⋅n1 

2 

n1 

Vereinfachen 

5 4⋅n⋅n1 

2⋅n1 

Vereinfachen 

52⋅n 



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 



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 



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 

4n 

– 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 

n 



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 



O-Notation 

● 

● 

T ∈ O(g) 

n 0 

≤ ·g(n) 

● gilt, dass T(n) c 

– Ab einem bestimmten n ist für 

ein bestimmtes c der Wert c·g(n) 

c·g(n) 

– T wächst nicht schneller als g 

– g ist eine asymptotische 

obere Schranke von T 

T(n) 

– Ab einem bestimmten n 

wächst g schneller als T 

immer größer als T(n) 

– Es existiert 

● eine Konstante c ≥ 0 

● eine Konstante n 0 

≥ 0 

● so dass für alle n ≥ n 0 

Formale Spezifikation T ∈ O(g) 

∃c≥0∃n 0 

≥0 ∀ n≥n 0 

: T n≤c⋅g n 



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 



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 ) 



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) 


i = 0 

while i < n and a[i] != s: 

i = i+1 

return i 



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)) 



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) 


i = 0 


i = i+1 

return i 



Einfluss auf die Analyse – Schleife 

● 

● 

Schleife ist Multiplikation 

// Algorithmus A, Schleife 

– Häufigkeit in Abhängigkeit von n 

● n·O(n) = O(n)·O(n) = O(n²) 

in der Schleifenkörper 

durchlaufen wird 

while t: 

f 

– Multiplizieren mit dieser Häufigkeit O(A) = O(f) · Anzahl Durchläufe in 

– Annahme: O(t) ≤ O(f) 

Abhängigkeit von n 

– n-maliges Durchlaufen 

// Algorithmus A, for-Schleife 

– Mit n multiplizieren 

for i in 1..n: 

f 

– Beispiel 

● n-maliges Durchlaufen (for Schleife) 

O(A) = O(f) · n 

● Linearer Algorithmus f 

For-Schleife 



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) 


i = 0 


i = i+1 

return i 



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 



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 



Typische Laufzeiten 

praktisch 

● Höhergradig polynomiell meist machbar 

Lösbaren 

● Exponentiell ist massiv unangenehm 

● Logarithmisch, linear und n·log(n) 

sind gut handhabbar 

polynomiell exponentiell 

Grenze des 



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 



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 ;-) 



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) 



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 


pos = 0 


pos = pos+1 

return pos 



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≤in−1 :a[i]≤a[i1] 

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 



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 



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) 



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)) 



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 



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

03 O-Notation, Laufzeit und KomplexitÃƒÂ¤t - Medieninformatik

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?