Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 3 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät

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)


Mathematisches Instrumentarium zur Messung der Komplexität (des Zeit- und Platzbedarfs von Algorithmen):

Groß-O-Kalkül (Landausche Symbole)

Beschreibung und Analyse von Algorithmen


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


Komplexitätsschranken

Schranke für speziellen Algorithmus

Komplexität des Problems

Untere Schranke aus der Theorie

Inputgröße

Komplexität


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)


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


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.


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


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


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


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


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


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.


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


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.


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


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


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


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)


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


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


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


Beispiele zur O-Notationen

f(n) = 2n2 + 3n + 1 = O(n2)

f(n) = n log n ist nicht in O(n)


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)


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.


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


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


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 )


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(


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


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;

}

}

Documents

Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 3 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät