algorithmen und datenstrukturen · 1 einfuhrung¨ 1.1 inhalt•wichtige datentypen und ihre...
TRANSCRIPT
![Page 1: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/1.jpg)
Informatik II
Algorithmen und
Datenstrukturen
Vorlaufige Version 1 c© 2002 Peter Thiemann
![Page 2: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/2.jpg)
1 Einfuhrung
1.1 Inhalt
• Wichtige Datentypen und ihre Implementierung (Datenstrukturen)
• Operationen auf Datenstrukturen (Algorithmen)
• Komplexitatsanalyse
– Laufzeitanalyse der Operationen
– Speicherverbrauchsanalyse
• Techniken des Algorithmenentwurfs
• Informell: Korrektheit der Algorithmen
Vorlaufige Version 2 c© 2002 Peter Thiemann
![Page 3: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/3.jpg)
1.2 Ziele
• Reproduktion
• Anwendung
• Implementierung
• Auswahlkriterien
• Komplexitatsanalyse einfacher Algorithmen
• Entwurfsideen fur Algorithmen
Vorlaufige Version 3 c© 2002 Peter Thiemann
![Page 4: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/4.jpg)
1.3 Hilfsmittel
• elementare Mathematik
(Folgen, Reihen, Grenzwerte, Abschatzungen, Kombinatorik)
• algorithmische Notation
z.B. Programmiersprache
Vorlaufige Version 4 c© 2002 Peter Thiemann
![Page 5: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/5.jpg)
1.4 Literatur
• T. Ottmann und P. Widmayer, Algorithmen und Datenstrukturen, 4. Auflage,
Spektrum Verlag, 2001.
Vorlaufige Version 5 c© 2002 Peter Thiemann
![Page 6: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/6.jpg)
2 Grundlagen der Komplexitatsanalyse
Referenzmaschine fur Komplexitatsanalyse: Turingmaschine
Definition 1 Sei M Turingmaschine fur einen Algorithmus A(x)
1. Laufzeit von A bei Eingabe von x
T (x) = ] Schritte, die M zur Berechnung von A(x)benotigt
2. Speicherplatzbedarf von A bei Eingabe von x
S(x) = ] Bandplatze, die M zur Berechnung von A(x)benotigt
Weitere Moglichkeiten fur Referenzmaschinen
1. RAM (random access machine)
2. RM (register machine)
Vorlaufige Version 6 c© 2002 Peter Thiemann
![Page 7: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/7.jpg)
Beispiel: tm-find0
Turingmaschine uber Alphabet 0, 1, die feststellt, ob die Eingabe 0 enthalt.
B
q0
1 1 0 1 1 1
N,0,qfq0 R,B,q0 N,B,qf
0 1
Startzustand q0; Endzustand qf ; akzeptiert, falls Kopf auf nicht-leerem Platz
x 0 1 110 110111
T(x) 1 2 3 3
S(x) 1 1 3 6
Vorlaufige Version 7 c© 2002 Peter Thiemann
![Page 8: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/8.jpg)
Probleme mit der Definition
1. Komplexitat hangt von konkreter Eingabe ab
2. Exakte Schrittzahl selten von Interesse
3. Algorithmen werden nicht in Form von Turingmaschinen aufgeschrieben
Vorlaufige Version 8 c© 2002 Peter Thiemann
![Page 9: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/9.jpg)
2.1 Abstraktion von der Eingabe
• Anstatt konkreter Eingabe x betrachte alle Eingaben der Große n = |x|
• Bestimme Anzahl der Schritte/Platze in Abhangigkeit von n
⇒ neues Problem: Eingaben gleicher Große konnen unterschiedlich viele
Schritte/Platze verbrauchen
• im Beispiel tm-find0
– Eingabe 00000000 braucht einen Schritt
– Eingabe 11101111 braucht vier Schritte
– Eingabe 11111111 braucht neun Schritte
Vorlaufige Version 9 c© 2002 Peter Thiemann
![Page 10: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/10.jpg)
Arten von Komplexitat
Losung: extrahiere einen Wert aus allen Werten T (x) mit |x| = n
• Tmin(n) = minT (x) | |x| = nbest-case Komplexitat
• Tmax(n) = maxT (x) | |x| = nworst-case Komplexitat
• T (n) =∑|x|=n T (x) · qn(x)
qn(x) ist Wahrscheinlichkeit, dass x als Eingabe der Große n auftritt
average-case Komplexitat
Vorlaufige Version 10 c© 2002 Peter Thiemann
![Page 11: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/11.jpg)
Bewertung
• best-case Komplexitat
leicht zu bestimmen, meist unwichtig
• worst-case Komplexitat
oft zu pessimistisch
• average-case Komplexitat
– praktisch relevant
– schwierig zu bestimmen
– Wahrscheinlichkeitsverteilung meist unbekannt
in Beweisen wird oft Gleichverteilung angenommen
d.h. qn(x) = m−1 wobei m = |x | |x| = n|
Vorlaufige Version 11 c© 2002 Peter Thiemann
![Page 12: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/12.jpg)
Beispiel: Laufzeitanalyse von tm-find0
• best-case
Tmin(n) = 1
falls x = 0 . . . or x = ε
• worst-case
Tmax(n) = n + 1
falls x = 1 . . . 1
• average-case
Annahme: Gleichverteilung, d.h. qn(x) = 2−n
T (n) = 1 · 0.5 + 2 · (0.5)2 + . . . + n · (0.5)n + (n + 1) · (0.5)n
= (∑n
k=1 k · 2−k) + (n + 1) · 2−n(1)
Vorlaufige Version 12 c© 2002 Peter Thiemann
![Page 13: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/13.jpg)
Nebenrechnung
∑nk=1 k · 2−k = 1 · 2−1 + 2 · 2−2 + 3 · 2−3 + . . .+ n · 2−n
= 2−1 + 2−2 + 2−3 + . . .+ 2−n
+ 2−2 + 2−3 + . . .+ 2−n
+ 2−3 + . . .+ 2−n
...
+ 2−n
(2)
Jede Zeile von (2) ist (Endstuck einer) geometrischen Folge
n∑k=0
qk =qn+1 − 1
q − 1(3)
Einsetzen von q = 1/2 in (3) ergibt
n∑k=0
(1/2)k =(1/2)n+1 − 1
1/2− 1= −2(1/2)n+1 + 2 = 2− 2−n (4)
Vorlaufige Version 13 c© 2002 Peter Thiemann
![Page 14: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/14.jpg)
In Zeile j ∈ 1, . . . , n von (2) steht gerade
2−j + 2−(j+1) + . . . + 2−n =∑n
k=0(1/2)k −∑j−1
k=0(1/2)k
(4)= 2− 2−n − (2− 2−(j−1))
= −2−n + 2−(j−1)
(5)
Also ergibt die Summe aller Zeilen in (2):∑nj=1−2−n + 2−(j−1) = −n · 2−n +
∑nj=1 2−(j−1)
= −n · 2−n +∑n−1
j=0 2−j
(4)= −n · 2−n + 2− 2−(n−1)
(6)
Einsetzen von (6) in (1) ergibt insgesamt
T (n) = −n · 2−n + 2− 2−(n−1) + (n + 1) · 2−n
= 2 + 2−n − 2−(n−1)
= 2 + 2−n − 2 · 2−n
= 2− 2−n
(7)
Vorlaufige Version 14 c© 2002 Peter Thiemann
![Page 15: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/15.jpg)
2.2 Komplexitat eines Problems
Unterschied: Komplexitat eines Problems ↔ Komplexitat eines Algorithmus
• Komplexitat eines Problems ist die minimale Laufzeit (Speicherplatzbedarf) eines
Algorithmus, der das Problem lost
Theorie: fur manche Probleme gibt es untere Schranken, d.h. kein Algorithmus
kann schneller laufen, als die untere Schranke angibt
oft schwer zu bestimmen
• Komplexitat eines konkreten Algorithmus liefert obere Schranke fur ein Problem
• Falls die Komplexitat eines Algorithmus der unteren Schranke eines Problems
entspricht, so liegt eine genaue Schranke vor.
Vorlaufige Version 15 c© 2002 Peter Thiemann
![Page 16: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/16.jpg)
2.3 Wachstumsklassen von Funktionen
• Genaue Zahl von Schritten selten interessant und/oder technisch aufwandig zu
ermitteln
• Variiert zwischen Implementierungen
• Verhalten wichtiger fur große Eingaben
asymptotisches Verhalten
• Unabhangigkeit von konstanten Faktoren
Anderung bei Technologiewechsel
⇒ Wachstumsverhalten von Funktionen ist interessanter
Vorlaufige Version 16 c© 2002 Peter Thiemann
![Page 17: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/17.jpg)
Definition: Landausche O-Notation
Seien f, g : N → R+ Funktionen
• f ∈ O(g) “f wachst nicht schneller als g”, falls
(∃c ∈ R+) (∃n0 ∈ N) (∀n ∈ N) n > n0 ⇒ f(n) ≤ c · g(n)
• f ∈ Ω(g) “f wachst mindestens so schnell wie g”, falls g ∈ O(f)
• f ∈ Θ(g) “f genauso schnell wie g”, falls f ∈ O(g) und g ∈ O(f)
• f ∈ o(g) “f wachst langsamer als g”, falls
limn→∞
f(n)g(n)
= 0
• f ∈ ω(g) “f wachst schneller als g”, falls g ∈ o(f)
Vorlaufige Version 17 c© 2002 Peter Thiemann
![Page 18: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/18.jpg)
Schreibweise
• Schreibe O(n log n) anstelle von
– O(λn.n log n) oder
– O(g) mit g(n) = n log n
• Oft: f = O(g) anstatt f ∈ O(g)Vorsicht, da Gesetze von = nicht gelten!
Vorlaufige Version 18 c© 2002 Peter Thiemann
![Page 19: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/19.jpg)
Beispiele
Sei f1(n) =√
n; f2(n) = n; f3(n) = nk fur k ≥ 1; f4(n) = 2n
• f1 ∈ O(f2), denn fur alle n > n0 = 1 gilt:√
n ≤ n (mit c = 1)
• f2 ∈ O(f3), denn fur alle n > n0 = 1 gilt: n ≤ nk (mit c = 1; fur alle k ≥ 1)
• f3 ∈ O(f4), denn es gilt sogar f3 ∈ o(f4):
limn→∞
nk
2n= lim
n→∞
k · nk−1
ln 2 · 2n= . . . = lim
n→∞
k!(ln 2)k · 2n
= 0
nach l´Hospital (k-fach angewendet)
Zur Erinnerung: Regel von l´Hospital
limn→∞
f ′(n)g′(n)
= c ⇒ limn→∞
f(n)g(n)
= c
falls limn→∞ f(n) = limn→∞ g(n) ∈ 0,±∞
Vorlaufige Version 19 c© 2002 Peter Thiemann
![Page 20: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/20.jpg)
Visualisierung des Großenwachstums
0
5
10
15
20
0 5 10 15 20
log(x)sqrt(x)
xx*x
x*x*xx*x*x*xexp(x)
Vorlaufige Version 20 c© 2002 Peter Thiemann
![Page 21: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/21.jpg)
Wachstumshierarchie
O(1): konstante Funktionen
O(log n): Logarithmische Funktionen
O(log2 n): Quadratisch logarithmische Funktionen
O(n): Lineare Funktionen
O(n log n): — keine spezielle Bezeichnung —
O(n2): quadratische Funktionen
O(n3): kubische Funktionen
O(nk): polynomielle Funktionen (fur festes k ≥ 1)
genauer: f heißt polynomiell beschrankt, wenn es ein Polynom p mit f = O(p) gibt
O(2n): exponentielle Funktionen
genauer: f wachst exponentiell, wenn es ein ε > 0 mit f = Θ(2nε
) gibt
Vorlaufige Version 21 c© 2002 Peter Thiemann
![Page 22: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/22.jpg)
Skalierbarkeit
Maximale Eingabelange bei gegebener Rechenzeit
Annahme: Rechenschritt 0.001 Sekunden.
Laufzeit T(n) 1 Sekunde 1 Minute 1 Stunde
n 1000 60000 3600000
n log n 140 4895 204094
n2 31 244 1897
n3 10 39 153
2n 9 15 21
Vorlaufige Version 22 c© 2002 Peter Thiemann
![Page 23: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/23.jpg)
Maximale Eingabelange in Abhangigkeit von Technologie
• Algorithmus mit Laufzeit T (n)
• p max. Eingabelange mit alter Technologie
• pneu max. Eingabelange mit neuer Technologie
• neue Technologie: 10-mal so schnell
• 10 · T (p) = T (pneu)
T (n) pneu Begrundung
n 10p
n log n (fast 10)p log 10p = log p + log 10 ≈ log p
n2 3.16p 3.162 ≈ 10
n3 2.15p 2.153 ≈ 10
2n p + 3.3 23.3 ≈ 10
Vorlaufige Version 23 c© 2002 Peter Thiemann
![Page 24: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/24.jpg)
Beispiel: Exponentieller Algorithmus
SAT (Erfullbarkeit einer Formel der Aussagenlogik)
Frage: Gegeben eine logische Formel mit n Variablen. Gibt es eine Belegung der
Variablen, so dass die Formel wahr (erfullt) ist?
Alternativ: Gegeben ein kombinatorischer Schaltkreis mit n Eingangen. Gibt es
eine Belegung der Eingange, so dass der Ausgang 1 ist?
Naive Losung: Durchprobieren aller 2n moglichen Belegungen.
⇒ exponentielle Laufzeit
Anmerkung: Es ist nicht bekannt, ob dieser Algorithmus der bestmogliche ist.
Vorlaufige Version 24 c© 2002 Peter Thiemann
![Page 25: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/25.jpg)
Weitere Eigenschaften
• Falls p1 und p2 Polynome vom Grad d1 bzw. d2 mit positivem Leitkoeffizienten
sind, so gilt
p1 ∈ Θ(p2) ⇔ d1 = d2
p1 ∈ o(p2) ⇔ d1 < d2
p1 ∈ ω(p2) ⇔ d1 > d2
• Fur alle k > 0 und ε > 0 gilt
logk n ∈ o(nε)
dabei ist logk n = (log n)k
• 2n/2 ∈ o(2n)
Vorlaufige Version 25 c© 2002 Peter Thiemann
![Page 26: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/26.jpg)
Rechenregeln fur O
• f ∈ O(f)
• O(f) = O(O(f))
• O(k · f) = O(f) fur Konstante k ≥ 0
• O(k + f) = O(f) fur Konstante k ≥ 0
• O(f) ·O(g) = O(f · g) Multiplikationsregel
• O(f) + O(g) = O(max(f, g)) Additionsregel
Vorlaufige Version 26 c© 2002 Peter Thiemann
![Page 27: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/27.jpg)
Beweis fur Additions- und Multiplikationsregel
Sei F ∈ O(f) und G ∈ O(g), d.h. es gibt cF , cG ∈ R+ sowie nF , nG ∈ N, sodass
(∀n > nF ) F (n) ≤ cF f(n) und (∀n > nG) G(n) ≤ cGg(n) ist.
Sei nun n0 = max(nF , nG).
Offenbar gilt fur c1 = cF · cG, dass
(∀n > n0) F (n) ·G(n) ≤ cF f(n) · cGg(n) = c(f · g)(n).Es gilt also die Multiplikationsregel: F ·G ∈ O(f · g).
Weiter gilt fur c2 = cF + cG, dass
(∀n > n0) F (n) + G(n) ≤ cF f(n) + cGg(n) ≤ c2(max(f, g))(n).Es gilt also die Additionsregel: F + G ∈ O(max(f, g)).
Vorlaufige Version 27 c© 2002 Peter Thiemann
![Page 28: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/28.jpg)
Die Wachstumsordnung auf Funktionen
Definition 2 Eine Relation R ⊆ M ×M , wobei M Menge, heißt
• reflexiv, falls (∀m ∈ M) m R m;
• transitiv, falls (∀m1,m2,m3 ∈ M) m1 R m2 ∧m2 R m3 ⇒ m1 R m3;
• symmetrisch, falls (∀m1,m2 ∈ M) m1 R m2 ⇔ m2 R m1;
• Vorordnung, falls R reflexiv und transitiv;
• Aquivalenzrelation, falls R reflexiv, transitiv und symmetrisch.
Vorlaufige Version 28 c© 2002 Peter Thiemann
![Page 29: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/29.jpg)
Fur M = f | r : N → R+ definiere
f g ⇔ f ∈ O(g)
f ≺ g ⇔ f ∈ o(g)
Es gilt:
• ≺ ist transitive Relation
• ist Vorordnung
• f ≺ g ⇒ f g
• Die Relation ≈, definiert durch f ≈ g, falls f g ∧ g f , ist eine
Aquivalenzrelation
• f ≈ g ⇔ f ∈ Θ(g)
Bemerkung: Die Relationen ≺,,≈ auf Funktionen haben ahnliche Eigenschaften wie
<,≤,= auf Zahlen.
Unterschied: Aus f ≈ g folgt nicht f = g!
Vorlaufige Version 29 c© 2002 Peter Thiemann
![Page 30: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/30.jpg)
2.4 Kostenmaße
• Programmiersprache statt Turingmaschine
• Einheitskostenmaß
– Konkrete Maschine hat feste Wortbreite (z.B. 32 Bit);
jedes Datenelement belegt gleichen Speicherplatz unabhangig von der Große
– Turingmaschinen fur Grundrechenarten, Vergleiche, Kopieren von 32 Bit Zahlen
benotigen 32 · c + d Schritte
⇒ eine Konstante unabhangig von der Große der Zahl
⇒ Aufwand fur diese Operationen ist O(1)
• logarithmisches Kostenmaß
– Jedes Datenelement belegt Platz in Abhangigkeit von seiner Große
– Platzbedarf fur Langzahl n in Dualdarstellung: dlog2 n + 1e– Grundrechenarten, Vergleiche, Kopieren benotigen O(dlog2 n + 1e) Schritte
Vorlaufige Version 30 c© 2002 Peter Thiemann
![Page 31: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/31.jpg)
2.5 Kosten fur Programmteile
Zuweisung: T (x := E) = |E|+ 1 ∈ O(1)
(E Ausdruck, ohne Funktionsaufrufe; Einheitskostenmaß)
Sequenz: T (S1; . . . ;Sn) = T (S1) + . . . + T (Sn)
Konditional: T (if E S1 S2) = T (E) + max(T (S1), T (S2))
Schleife: T (while E do S) =∑n
i=1 Ti(E) + Ti(S)
Rekursion: T selbst rekursiv definiert
Bemerkung: oft werden nur “wichtige Operationen” gezahlt: Vergleiche,
Datenbewegungen, usw
Vorlaufige Version 31 c© 2002 Peter Thiemann
![Page 32: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/32.jpg)
2.6 Beispiele
2.6.1 Algorithmus Bubble-Sort
Sortiert die Zahlen im Array a[1..n] durch wiederholtes Vertauschen.
repeat
for (i = 1; i < n; i++)
if (a[i] > a[i+1])
swap(a, i, i+1)
until (keine Vertauschungen mehr notwendig)
Abschatzen der Anzahl von Vergleichen:
Worst Case: Innere Schleife: n− 1 Vergleiche, maximal n Durchlaufe (Minimum an
a[n]) der außeren Schleife ⇒ O(n2)
Best Case: Array ist bereits sortiert: Ende nach einem Durchlauf ⇒ O(n)
Average Case: auch O(n2) viele Vergleiche ausgefuhrt.
Vorlaufige Version 32 c© 2002 Peter Thiemann
![Page 33: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/33.jpg)
2.6.2 Das Maxsummenproblem
Problem MaxSum: Betrachte ein Array a[1..n] von ganzen Zahlen. Berechne
maxf(i, j) | 1 ≤ i ≤ j ≤ n, wobei f(i, j) = ai + . . . + aj . Rechenschritte sind
arithmetische Operationen und Vergleiche.
Naiver Algorithmus
Berechne alle Werte von f(i, j) und bestimme dabei das Maximum.
m := f (1,1)
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++)
if (f (i,j) > m)
m := f (i,j)
Die Berechung von f(i, j) benotigt j − i Additionen.
Vorlaufige Version 33 c© 2002 Peter Thiemann
![Page 34: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/34.jpg)
Analyse Naiver Algorithmus Es gibt j Paare der Form (·, j)
# Vergleiche: V1(n) =∑n
j=1 j ∈ O(n2)
# Additionen:
A1(n) =n∑
i=1
n∑j=i
(j − i)
=n∑
i=1
n−i∑k=1
k
∈ O(n3)
# Rechenschritte: T1(n) = V1(n) + A1(n) ∈ O(n2) + O(n3) = O(n3).
Tatsachlich auch Ω(n3).
Vorlaufige Version 34 c© 2002 Peter Thiemann
![Page 35: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/35.jpg)
2.6.3 Der etwas bessere Algorithmus
Verwende f(i, j + 1) = f(i, j) + aj+1
m := f (1,1)
for (i = 1; i <= n; i++)
fij := 0
for (j = i; j <= n; j++)
fij := fij + a[j]
if (fij > m)
m := fij
Damit braucht man fur alle f(i, ·)-Werte genau (n− i + 1) Additionen.
# Vergleiche: V2(n) = V1(n) ∈ O(n2).
# Additionen: A2(n) =∑n
i=1(n− i + 1) = n +∑n−1
k=1 k ∈ O(n2).
# Rechenschritte: T2(n) = V2(n) + A2(n) ∈ O(n2).
Vorlaufige Version 35 c© 2002 Peter Thiemann
![Page 36: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/36.jpg)
2.6.4 Divide-And-Conquer Algorithmusa
Zur Losung von MaxSum auf a[1..n] unterteile die Menge der Index-Paare (i, j) in
drei Klassen:
1. 1 ≤ i, j ≤ n/2 MaxSum auf a[1..n/2]
2. 1 ≤ i ≤ n/2 < j ≤ n neues Problem auf a[1..n]!
3. n/2 < i ≤ j ≤ n MaxSum auf a[n/2+1..n]
• Die Probleme 1 und 3 sind halb so groß wie das ursprungliche Problem und werden
rekursiv gelost.
• Fur Problem 2 setze
– g(i) = ai + . . . + an/2 fur 1 ≤ i ≤ n/2
– h(j) = an/2+1 + . . . + aj fur n/2 < j ≤ n
⇒ f(i, j) = g(i) + h(j)
Es gilt: f(i, j) maximal ⇔ g(i) und h(j) maximal
a(lat. divide et impera) teile und herrsche
Vorlaufige Version 36 c© 2002 Peter Thiemann
![Page 37: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/37.jpg)
• Berechne nacheinander (in n/2− 1 Additionen)
g(n/2) = an/2
g(n/2− 1) = an/2−1 + an/2
...
g(1) = a1 + . . . + an/2
und daraus den maximalen Wert von g in (n/2− 1) Vergleichen.
• Berechne den maximalen Wert von h analog.
• Damit ergeben sich fur das zweite Problem insgesamt n− 1 Additionen und n− 2Vergleiche, also 2n− 3 Operationen, obwohl die Klasse n2/4 Paare (i, j) enthalt.
• Gesamtergebnis aus Losungen fur 1, 2 und 3 durch 2 Vergleiche.
Vorlaufige Version 37 c© 2002 Peter Thiemann
![Page 38: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/38.jpg)
Rekursionsgleichung
T3(1) = 0
T3(n) = 2T3(n/2) + 2 · n− 3 + 2
Losungsansatz: Angenommen n = 2k
T3(2k) = 2T3(2k−1) + 2k+1 − 1
= 4T3(2k−2) + 2k+1 − 2 + 2k+1 − 1
= 8T3(2k−3) + 2k+1 − 4 + 2k+1 − 2 + 2k+1 − 1
= . . .
= 2k · T3(2k−k) + k · 2k+1 −∑k
i=1 2i−1
= 0 + 2k · 2k − 2k + 1
= (2k − 1)2k + 1
Aus n = 2k ergibt sich k = log2 n und somit
= (log2 n− 1)n + 1
∈ O(n log n)
Vorlaufige Version 38 c© 2002 Peter Thiemann
![Page 39: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/39.jpg)
2.6.5 Scanline Algorithmus
• MaxSum lasst sich mit einem Durchlauf durch a[1..n] losen
Gesucht: maxsumk = max∑j
l=i al | 1 ≤ i ≤ j ≤ kHilfsgroße: maxtailk = max
∑kl=i al | 1 ≤ i ≤ k
• Fur k = 1 setze maxsum1 = a1 und maxtail1 = a1.
• Fur k = 1, . . . , n− 1 setze
maxtailk+1 = max∑k+1
l=i al | 1 ≤ i ≤ k + 1= max(ak+1 +
∑kl=i al | 1 ≤ i ≤ k ∪ ak+1)
= max(ak+1 + maxtailk, ak+1)
maxsumk+1 = max∑j
l=i al | 1 ≤ i ≤ j ≤ k + 1= max(
∑jl=i al | 1 ≤ i ≤ j ≤ k ∪
∑k+1l=i al | 1 ≤ i ≤ k + 1)
= max(maxsumk,maxtailk+1)
⇒ T4(n) = (n− 1) · 3 = 3n− 3 Operationen
Vorlaufige Version 39 c© 2002 Peter Thiemann
![Page 40: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/40.jpg)
2.6.6 Zusammenstellung der Ergebnisse
Naiv: T1(n) ∈ O(n3)Besser: T2(n) ∈ O(n2)Divide-and-Conquer: T3(n) ∈ O(n log n)Scanline: T4(n) ∈ O(n)
Bemerkung: Es ist moglich, den Scanline Algorithmus aus dem naiven Algorithmus
herzuleiten!
Vorlaufige Version 40 c© 2002 Peter Thiemann
![Page 41: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/41.jpg)
2.7 Mastertheorem
Gegeben eine Rekursionsgleichung fur T : N → R.
T (n) =
c falls n ≤ d
aT (n/b) + f(n) falls n > d.
Dabei sind c ≥ 1 und d ≥ 1 naturliche Zahlen, a ≥ 1 und b > 1 reelle Konstanten und
f eine reelle Funktion mit f(n) ≥ 0 fur n ≥ d. Unterscheide drei Falle:
1. (∃ε > 0) f(n) ∈ O(nlogb a−ε) ⇒
T (n) ∈ Θ(nlogb a)
2. (∃k ≥ 0) f(n) ∈ Θ(nlogb a(log n)k) ⇒
T (n) ∈ Θ(nlogb a(log n)k+1)
3. (∃ε > 0) f(n) ∈ Ω(nlogb a+ε) und
(∃δ < 1) (n ≥ d) af(n/b) ≤ δf(n) ⇒
T (n) ∈ Θ(f(n))
Vorlaufige Version 41 c© 2002 Peter Thiemann
![Page 42: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/42.jpg)
Beispiele Mastertheorem
1. T (n) = 4T (n/2) + n; a = 4, b = 2, f(n) = n. Mit nlog2 4 = n2 ist
T (n) ∈ Θ(n2),
da Fall 1 gilt: n = f(n) ∈ O(n2−ε) fur ε = 1.
Genau: T (n) = 2n2 − n
2. T (n) = T (n/2) + 1; a = 1, b = 2, f(n) = 1. Mit nlog2 1 = 1 ist
T (n) ∈ Θ(log n),
da Fall 2 mit k = 0 gilt.
Genau: T (n) = log n + 1
3. T (n) = 2T (n/2) + n log n; a = 2, b = 2, f(n) = n log n. Mit nlog2 2 = n ist
T (n) ∈ Θ(n log2 n),
da Fall 2 mit k = 1 gilt.
Vorlaufige Version 42 c© 2002 Peter Thiemann
![Page 43: Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre Implementierung (Datenstrukturen) •Operationen auf Datenstrukturen (Algorithmen) •Komplexit¨atsanalyse](https://reader033.vdocuments.site/reader033/viewer/2022060815/6093a28f9563cd7478300b92/html5/thumbnails/43.jpg)
4. T (n) = T (n/3) + n log n; a = 1, b = 3, f(n) = n. Mit nlog3 1 = 1 ist
T (n) ∈ Θ(n),
da Fall 3 gilt: f(n) = Ω(n0+ε) fur ε = 1 und fur δ = 1/3 gilt
af(n/b) = (n/3) log(n/3) = (n/3)(log n− log 3) ≤ (n/3) log n = f(n)/3
Vorlaufige Version 43 c© 2002 Peter Thiemann