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