Informatik II, SS 2008Algorithmen und Datenstrukturen
Vorlesung 3Prof. Dr. Thomas Ottmann
Algorithmen & Datenstrukturen, Institut für InformatikFakultät für Angewandte WissenschaftenAlbert-Ludwigs-Universität Freiburg
Funktionenklassen zur Messung der Komplexität
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 2
Lernziele
Algorithmen für wichtige Probleme :
Sortieren, Suchen, Wörterbuch-Problem, Berechnung kürzester Pfade, . . .
Datenstrukturen :
Listen, Stapel, Schlangen, Bäume, Hash-Tabellen, . . .
Problemlösetechniken :
Divide-and-Conquer, Greedy, vollständige Aufzählung, Backtracking, . . .
Ziele:
Finden effizienter Algorithmen für Instanzen von Problemen aus einem gegebenen Bereich
Fähigkeit zur Beurteilung von Algorithmen aufgrund präziser Kriterien (Korrektheit, Effizienz)
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 3
Mathematisches Instrumentarium zur Messung der Komplexität (des Zeit- und Platzbedarfs von Algorithmen):
Groß-O-Kalkül (Landausche Symbole)
Beschreibung und Analyse von Algorithmen
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 4
Effizienzanalyse
Laufzeitkomplexität: Steht die Laufzeit im akzeptablen/ vernünftigen/ optimale Verhältnis zur Größe der Aufgabe?
Speicherplatzkomplexität: Wird primärer (sekundärer) Speicherplatz effizient genutzt?
Theorie: Kann untere Schranken liefern, die für jeden Algorithmus gelten, der das Problem löst (etwa (n log n) Schritte für jedes allgemeine Sortierverfahren mit n Elementen)
Spezieller Algorithmus: Liefert obere Schranke für die Lösung eines Problems (etwa O(n2) Schritte für Bubblesort mit n Elementen)
Effiziente Algorithmen und Komplexitätstheorie: Zweige der Theoretischen Informatik zur Erforschung von oberen und unteren Schranken
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 5
Komplexitätsschranken
Schranke für speziellen Algorithmus
Komplexität des Problems
Untere Schranke aus der Theorie
Inputgröße
Komplexität
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 6
Laufzeitanalyse (1)
Ein Programm P, das für eine Problembeschreibung x mit Länge n=|x| die Lösung findet, habe Laufzeit TP (n)
Der beste Fall (best case): Laufzeit meist leicht bestimmbar, kommt in der Praxiseher selten vor:
TP,best(n) = inf {TP(x) | n = |x|}
Der schlechteste Fall (worst case): Liefert garantierte Schranken, Laufzeit meistleicht bestimmbar, aber meist zu pessimistisch in der Praxis:
TP,worst(n) = sup {TP(x) | n = |x|}
Im amortisierten worst case wird der durchschnittliche Aufwand für eineschlechtestmögliche Folge von Eingaben bestimmt (technisch anspruchsvoll).
Der mittlere Fall (average case): Z.B. Mittelung über alle Eingaben mit Länge n
TP,average(n) = 1/(#(x)mit|x|=n) ∑|x|=n TP(x)
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 7
Messung des Leistungsverhaltens
Betrachte konkrete Implementierung auf konkreter Hardware. Miss Laufzeit undPlatzverbrauch für repräsentative Eingaben.
Berechne Verbrauch an Platz und Zeit für idealisierte Referenzmaschine, RandomAccess Machine (RAM), Registermachine (RM), Turingmachine (TM), . . .
Bestimme Anzahl bestimmter (teurer) Grundoperationen, etwa• # Vergleiche, # Bewegungen von Daten (beim Sortieren)• # Multiplikationen/Divisionen (für numerische Verfahren)
Bei 2. und 3.: Beschreibe Aufwand eines Verfahrens als Funktion der Größe des Inputs.(Die Input-Größe kann verschieden gemessen werden.)
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 8
Beispiel: Taktzahl (1)
Bestimme Aufwand (Taktzahl = Anzahl der Bitwechsel) eines Von-
Neumann Addierwerks bei Addition einer 1 zu einer durch n
Binärziffern gegebenen Zahl i.
0 ≤ i ≤ 2n -1
Bester Fall:Die best case Rechenzeit beträgt 1 Takt(Addiere 1 zu 000……00)
Schlechtester Fall:Die worst case Rechenzeit beträgt n + 1 Takte(Addiere 1 zu 111…… 11)
Die Taktzahl ist 1 plus # der 1en am Ende der Darstellung von i.
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 9
Beispiel: Taktzahl (2)
Mittlerer Fall:Angenommen wird die Gleichverteilung auf der Menge der Eingaben. Es gibt 2n-k Eingaben, die mit enden und k Takte benötigen. Die Zahl 2n - 1 braucht n + 1 Takte.
Die average case Rechenzeit beträgt also
Im Mittel reichen also 2 Takte, um eine Addition von 1 durchzuführen.
1
1...10k
nnn
nk
knnadd
nn
nknT
22))1(22(2
)1(221
)(
1
11
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 10
Nebenrechnung
n
nk
n
n
n
nn
nnn
nnnn
nk
kn
22
)12(...)12(
2
2...2
22...2
222...2
2*12*2...2*2
1
1
0
30
230
1230
12
1
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 11
Primitive Operationen
Grundlegende Berechnungen, die von einem Algorithmus ausgeführt werden
Ablesbar aus Pseudocode oder Programmstück
Überwiegend unabhängig von einer (imperativen) Programmiersprache
Exakte Definition ist nicht bedeutend
Beispiele einen Ausdruck auswerten
einer Variablen einen Wert zuweisen
Indexierung in einem Array
Aufrufen einer Methode
Verlassen einer Methode
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 12
Zählen von primitiven Operationen
Durch Untersuchen des Pseudocode können wir die maximale Zahl von primitiven Operationen, die durch einen Algorithmus ausgeführt wurden, als eine Funktion der Eingabegröße bestimmen.
Algorithmus arrayMax(A,n) # Operationen
currentMax = A[0] 2
for i = 1 to n-1 do 2(n-1)
if A[i] > currentMax then 2(n-1)
currentMax = A[i] 2(n-1)
{ erhöhe Zähler i }
return currentMax 1
Total 6n-3
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 13
Laufzeit abschätzen
Der Algorithmus arrayMax führt im worst case 6n - 3 primitive Operationen aus
Definiere a Zeit, die die schnellste primitive Operation verbraucht hatb Zeit, die die langsamste primitive Operation verbraucht hat
T(n) sei die tatsächliche worst-case Laufzeit von arrayMax . Dann ist :
Daher ist die Laufzeit T(n) durch zwei lineare Funktionen beschränkt.
)36()()36( nbnTna
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 14
Zuwachsrate der Laufzeit
Verändern der Hard- und Softwareumgebung- beeinflusst T(n) um einen konstanten Faktor,
aber- ändert die Wachstumsordnung von T(n) nicht
Das lineare Wachstum der Laufzeit T(n) ist eine für den Algorithmus arrayMax charakteristische Eigenschaft.
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 15
Primitive Operationen
Grundlegende Berechnungen, die von einem Algorithmus ausgeführt werden
Ablesbar aus Pseudocode oder Programmstück
Überwiegend unabhängig von einer (imperativen) Programmiersprache
Exakte Definition ist nicht bedeutend
Beispiele einen Ausdruck auswerten
einer Variablen einen Wert zuweisen
Indexierung in einem Array
Aufrufen einer Methode
Verlassen einer Methode
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 16
Funktionenklassen
Groß-O-Notation:Mit der O-, - und -Notation sollen obere, untere bzw. genaue Schranken für das Wachstum von Funktionen beschrieben werden.
Idee:Konstante Summanden und Faktoren dürfen bei der Aufwandsbestimmungvernachlässigt werden.
Gründe:• Man ist an asymptotischem Verhalten für große Eingaben interessiert• Genaue Analyse kann technisch oft sehr aufwendig oder unmöglich sein• Lineare Beschleunigungen sind ohnehin immer möglich (Ersatz von Hardware/Software)
Ziel: Komplexitätsmessungen mit Hilfe von Funktionenklassen. Beispielsweise bezeichnet O(f) die Klasse der Funktionen, die (höchstens) von der Größenordnung von f sind.
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 17
Die O-Notation
Sei eine Funktion g: N → R+ gegeben, dann ist O(g) folgende Menge von Funktionen:
Die O-Notation gibt also eine asymptotisch obere Grenze für eine Funktion.
Wenn f zu O(g) gehört, sagt man: f ist Groß-O-von g und schreibt:
f(n) O(g(n))
oder auch (mathematisch fragwürdig):
f(n) = O(g(n))
} allefür g(n)c f(n) 0
mit , Konstanten positivegibt es |:{)(
01
01
nn
ncRNfg
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 18
Veranschaulichung der O-Notation
Die Funktion f gehört zur Menge O(g), wenn es positive Konstanten c und n0 gibt, so dass f(n) ab n0 unter c g(n) liegt.
n0
f(n)
c g(n)
n
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 19
Die Ω -Notation
Sei eine Funktion g: N → R+ gegeben, dann ist (g) folgende Menge von Funktionen:
Die -Notation gibt also eine asymptotisch untere Grenze für eine Funktion.
Wenn f zu (g) gehört, sagt man: f ist Groß-Omega-von g und schreibt:
f(n) (g(n))
oder auch (mathematisch fragwürdig):f(n) = (g(n))
} allefür f(n) g(n)c 0
mit , Konstanten positivegibt es |:{)(
01
01
nn
ncRNfg
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 20
Veranschaulichung der Ω -Notation
Die Funktion f gehört zur Menge (g), wenn es positive Konstanten c und n0 gibt, so dass f(n) ab n0 oberhalb von c g(n) liegt.
n0
n
f(n)
c g(n)
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 21
Die Θ -Notation
Sei eine Funktion g: N → R+ gegeben, dann ist (g) folgende Menge von Funktionen:
Die -Notation gibt also eine asymptotisch feste Grenze für eine Funktion.
Wenn f zu (g) gehört, sagt man: f ist Groß-Theta-von g und schreibt:
f(n) (g(n))
oder auch (mathematisch fragwürdig):f(n) = (g(n))
} allefür g(n)c f(n) g(n)c 0
mit ,, Konstanten positivegibt es |:{)(
021
021
nn
nccRNfg
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 22
Veranschaulichung der Θ -Notation
Die Funktion f gehört zur Menge (g), wenn es positive Konstanten c1, c2 und n0 gibt, so dass f(n) ab n0 zwischen c1 g(n) und c2 g(n) eingepackt werden kann.
n0
f(n)
c1g(n)
c2g(n)
n
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 23
Bemerkungen zu den O-Notationen
In manchen Quellen findet man leicht abweichende Definitionen, etwa
Für die relevantesten Funktionen f (etwa die monoton steigenden f nicht kongruent 0) sind diese Definitionen äquivalent.
} allefür )()(
mit und Konstanten positivegibt es |:{)(
nbnagnf
baRNfg
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 24
Beispiele zur O-Notationen
f(n) = 2n2 + 3n + 1 = O(n2)
f(n) = n log n ist nicht in O(n)
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 25
Eigenschaften von Groß-O
Transitivität: Ist f(n) = O(g(n)) und g(n) = O(h(n)), dann ist f(n) = O(h(n))
Additivität: Ist f(n) = O(h(n)) und g(n) = O(h(n)), dann ist f(n) + g(n) = O(h(n))
Für konstantes a ist: a nk = O(nk)
nk = O(nk+j), für jedes positive j.
f(n) = aknk + ak-1nk-1 + … + a1n1 + a0 = O(nk)
Ist f(n) = c g(n) für konstantes c, so ist f(n) = O(g(n))
Für beliebige positive Zahlen a, b ≠ 1 ist f(n) = logan = O(logbn)
Für beliebige positive a ≠ 1 ist logan = O(log2n)
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 26
Der O-Kalkül
Einfache Regeln: f = O(f)
O(O(f)) = O(f) k O(f) = O(f), für konstantes kO(f + k) = O(f), für konstantes k
Additionsregel:O(f) + O(g) = O( max{f, g} )
Multiplikationsregel:O(f) O(g) = O( fg )
Additionsregel findet Anwendung bei der Berechnung der Komplexität, wenn Programmteile hintereinander ausgeführt werden.
Multiplikationsregel findet Anwendung bei der Berechnung der Komplexität, wenn Programmteile ineinander geschachtelt werden.
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 27
Beispiele zur Laufzeitabschätzung(1)
Algorithmus prefixAverages1(X)
Eingabe: Ein Array X von n Zahlen
Ausgabe: Ein Array A von Zahlen, so dass gilt: A[i] ist das arithmetische Mittel der Zahlen X[0], …, X[i]
Methode:
for i = 0 to n-1 do
a = 0;
for j = 0 to i do
a = a + X[j]
A[i] = a/(i + 1)
return array A
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 28
Beispiele zur Laufzeitabschätzung(2)
Algorithmus prefixAverages2(X)
Eingabe: Ein Array X von n Zahlen
Ausgabe: Ein Array A von Zahlen, so dass gilt: A[i] ist das arithmetische Mittel der Zahlen X[0], …, X[i]
Methode:
s = 0;
for i = 0 to n-1 do
s = s + X[i];
A[i] = s/(i + 1)
return array A
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 29
Hierarchie von Größenordnungen
Größenordnung Name
O(1) konstante Funktionen
O(log n) logarithmische Funktionen
O(log2 n) quadratisch logarithmische Funktionen
O(n) lineare Funktionen
O(n log n) n log n-wachsende Funktionen
O(n2) quadratische Funktionen
O(n3) kubische Funktionen
O(nk) polynomielle Funktionen
f heißt polynomiell beschränkt ,wenn es ein Polynom p mit f = O(p) gibt.
f wächst exponentiell , wenn es ein > 0 gibt mit f = (2n )
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 30
Skalierbarkeiten
Annahme: 1 Rechenschritt benötigt 0.001 Sekunden. Maximale Eingabelänge bei gegebener Rechenzeit.
Annahme: Es kann auf einen 10-fach schnelleren Rechner gewechselt werden. Statt eines Problems der Größe p kann in gleicher Zeit dann berechnet werden:
Laufzeit T(n) 1 Sekunde 1 Minute 1 Stunde
n
n
n
nn
n
2
³
²
log
9
10
31
140
1000
21
153
1897
204094
3600000
15
39
244
4895
60000
Laufzeit T(n) neue Problemgröße
n
n
n
nn
n
2
³
²
log
p
p
p
p
p
32.3
15.2
16.3
)10(
10
fast
p
p
p
pppLambertW
p
10log
10
10
10
3
))ln(10(
)ln(
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 31
Bestimmung des Zeitaufwands
Sei A ein Programmstück, dessen Zeitaufwand cost(A) zu bestimmen ist:
1. A ist einfache Anweisung (read, write, +, -, . . . ):
cost(A) = const O(1)
2. A ist Folge von Anweisungen: Additionsregel anwenden
3. A ist if-Anweisung:
(a) if (cond) B; cost(A) = cost(cond) + cost(B)
(b) if (cond) B; else C; cost(A) = cost(cond) + max(cost(B), cost(C))
4. A ist eine Schleife (while, for, . . . ):
5. A ist Rekursion . . .
ung))ungsbeding(Terminiercosten)(Anweisungcost(*Umläufe#)cost(
einfach oft
)ungungsbeding(Terminier cost)en (Anweisungcost)(costUmlauf
i
ii
Informatik II: Algorithmen und Datenstrukturen, SS 2008Prof. Dr. Thomas Ottmann 32
Implementation in Java
class Mult {
public static void main ( String [] args ) {
int x = new Integer (args[0]). intValue();
int y = new Integer (args[1]). IntValue();
System.out.println (“Das Produkt von “ +x+ “ und
“ +y+ “ ist “ +mult(x,y));
public static int mult (int x, int y) {
int z = 0;
while (y>0)
if (y % 2 == 0) { y = y / 2; x = x+x ;}
else { y = y-1; z = z+x; }
return z;
}
}