Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre...
Transcript of Algorithmen und Datenstrukturen · 1 Einfuhrung¨ 1.1 Inhalt•Wichtige Datentypen und ihre...
Informatik II
Algorithmen und
Datenstrukturen
Vorlaufige Version 1 c© 2002 Peter Thiemann
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
1.2 Ziele
• Reproduktion
• Anwendung
• Implementierung
• Auswahlkriterien
• Komplexitatsanalyse einfacher Algorithmen
• Entwurfsideen fur Algorithmen
Vorlaufige Version 3 c© 2002 Peter Thiemann
1.3 Hilfsmittel
• elementare Mathematik
(Folgen, Reihen, Grenzwerte, Abschatzungen, Kombinatorik)
• algorithmische Notation
z.B. Programmiersprache
Vorlaufige Version 4 c© 2002 Peter Thiemann
1.4 Literatur
• T. Ottmann und P. Widmayer, Algorithmen und Datenstrukturen, 4. Auflage,
Spektrum Verlag, 2001.
Vorlaufige Version 5 c© 2002 Peter Thiemann
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
• 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
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
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
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
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
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
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