Algorithmik 1 - Friedrich-Alexander - Universität Erlangen

Werbung
Algorithmik 1
Prof. Dr. Michael Philippsen / Prof. Dr. Herbert Stoyan
Friedrich-Alexander-Universität
Erlangen-Nürnberg
Informatik 2/8
Programmiersysteme /
Künstliche Intelligenz
Organisatorisches
ƒ Regelung um die Weihnachtspause:
y Dienstag, 23.12.2003: Vorlesung fällt aus
y Mittwoch, 07.01.2004: Vorlesung findet statt
y Der Tutorienbetrieb läuft bis zum 23.12.2003 (einschließlich)
und startet wieder am 7.1.2004.
y Verlängerte Abgabefristen
à Lotto-Aufgabe von Blatt 8: Montag, 12.1.2004, 9:00 Uhr
à 9. Übungsblatt: Montag, 12.1.2004, 9:00 Uhr.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-2
M. Philippsen
Kapitel 13 - Skalierbarkeit und Aufwand
13.1
13.2
13.3
13.4
Charakterisierung von Aufwänden
Aufwände von Algorithmen
Charakterisierung von Aufwänden, Fortsetzung
Rekurrenzen
Handy aus!
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-3
M. Philippsen
Algorithmenwahl
Dienst
Algorithmen und
Datenstrukturen
Zuverlässigkeit
Korrektheit
Robustheit
Aufwand
Skalierbarkeit
Skalierbarkeit: Beherrschbarkeit des Wachstums
geeignete Funktionalität
⇒ Klasse
Dynamische Mengen,
ADT
moderat
steigender Aufwand ⇒
Algorithmus
O-Kalkül, Komplexität
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-4
M. Philippsen
13.1 Charakterisierung von Aufwänden
Aufwand
ƒ Die Größe der Menge der Eingabedaten für einen Algorithmus kann
stark variieren.
ƒ Das Verhalten eines Algorithmus sollte durch die Größe der
Eingabedaten nur moderat beeinflusst werden:
y Zum Beispiel soll ein Sortieralgorithmus 10, 100, 1000, 10000, ...
Datenelemente sortieren können, ohne bei mehr Elementen bedeutend
mehr Ressourcen (Zeit, Speicher) zu benötigen.
ƒ Bei der Implementierung eines Algorithmus sollte man also danach
streben, dass der Zeit- und Speicheraufwand nur moderat mit der
Größe der Eingabedaten wächst.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-5
M. Philippsen
13.1 Charakterisierung von Aufwänden
Beispiel: Counting Sort
ƒ Sortieren natürlicher Zahlen x[0],...,x[n]
Häufigkeit des
Vorkommens
// Maximum suchen
...
s
for (int i=0; i<=n; i++)
0 1 2
n Durchläufe if (x[i]> max) max=x[i];
// Neues Feld der Länge max+1 initialisieren
int s[] = new int[max+1];
max Durchläufe
for (int i=0; i<=max; i++) s[i]=0;
// Zähle, wie oft welche Zahl in x vorkommt
for (int i=0; i<=n; i++) s[x[i]]++;
n Durchläufe
// x neu auffüllen
for (int i=0, j=0; i<=max; i++)
while (s[i]>0) {x[j++]=i; s[i]--;}
mind. max Durchläufe
max
ƒ Insgesamt 2·n+2·max Schleifendurchläufe zum Sortieren von n
natürlichen Zahlen (Duplikate möglich).
ƒ Taugt der Algorithmus was? Unter welchen Umständen ist er sinnvoll?
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-6
M. Philippsen
13.1 Charakterisierung von Aufwänden
Vergleich von Algorithmen
ƒ Algorithmen
y verbrauchen Rechenzeit:
à Ausführungszeit des Programms selbst
à In der Praxis auch: Zeit für Ein-/Ausgabe, Zeit für Betriebsystem,...
y verbrauchen Speicher für Programm und Datenstrukturen:
à Platz für das Programm selbst
à Platz für seine statischen Datenstrukturen
à Platz für seine dynamischen Datenstrukturen
ƒ Fragestellungen:
y Ist Algorithmus A schneller/sparsamer als Algorithmus B?
y Kann ein Algorithmus signifikant verbessert werden?
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-7
M. Philippsen
13.1 Charakterisierung von Aufwänden
Umfang und Aufwand
ƒ Umfang n :
ƒ Aufwand T(n) :
Anzahl der Eingabewerte,
z.B. Länge einer Liste
Meist Anzahl der Zeiteinheiten, die der
Algorithmus für Problem mit Umfang n benötigt.
Manchmal: Anzahl der Speichereinheiten.
ƒ Hängt der Aufwand nicht nur vom Umfang ab, sondern auch von den
tatsächlichen Eingabewerten, dann interessiert ferner:
y ungünstigster Aufwand („worst-case“)
y mittlerer Aufwand („average-case“)
y Aufwand im besten Fall („best-case“)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-8
M. Philippsen
13.1 Charakterisierung von Aufwänden
Binärer Suchbaum
= Binärbaum, für dessen Knoten k gilt
value(left) < value(k) < value(right),
falls die Kinder existieren.
ƒ Es muss eine (totale) Ordnungsrelation < auf dem Elementtyp T
existieren, damit man die Werte der Knoten vergleichen kann.
6
ƒ Beispiel
<
<
3
<
1
<
4
<
8
10
Welchen Aufwand hat
das Einfügen eines
neuen Knotens?
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-9
M. Philippsen
13.1 Charakterisierung von Aufwänden
Suchbäume sehen je nach Einfügereihenfolge anders aus (1)
ƒ 4Æ2Æ5Æ3
4
2
5
Beim Einfügen von 3 müssen 2
Knoten untersucht werden.
3
ƒ 2Æ4Æ3Æ5
2
Beim Einfügen von 5 müssen 2
Knoten untersucht werden.
4
3
5
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-10
M. Philippsen
13.1 Charakterisierung von Aufwänden
Suchbäume sehen je nach Einfügereihenfolge anders aus (2)
ƒ 5Æ4Æ3Æ2
5
4
Beim Einfügen von 2 müssen 3
Knoten untersucht werden.
4
Beim Einfügen von 5 muss nur 1
Knoten untersucht werden.
3
2
ƒ 4Æ3Æ2Æ5
3
5
2
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-11
M. Philippsen
13.1 Charakterisierung von Aufwänden
Suchbäume sehen je nach Einfügereihenfolge anders aus (3)
ƒ Der Aufwand des Einfügens hängt ab von …
y … der Anzahl der schon vorhandenen Knoten im Baum (Umfang n)
y … den tatsächlichen Eingabewerten.
ƒ Zeitaufwand im besten Fall:
y 1 Knoten muss untersucht werden
ƒ Zeitaufwand im schlechtesten Fall:
y
y
y
y
n Knoten sind in absteigender Sortierung eingefügt worden.
Der Baum ist zur Liste degeneriert.
Der einzufügende n+1-te Knoten hat den kleinsten Wert.
Alle n vorhandenen Knoten müssen untersucht werden.
ƒ Mittlerer Zeitaufwand:
y Bei gleichverteilten Knotenwerten müssen log n Knoten untersucht
werden.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-12
M. Philippsen
13.1 Charakterisierung von Aufwänden
Asymptotischer Aufwand
ƒ Der exakte Aufwand eines Algorithmus etwa in Form der Anzahl der
Rechenschritte bis zur Terminierung oder der verbrauchten Zeit ist kaum
berechenbar.
ƒ Lineare Faktoren sind für die Theorie uninteressant.
y Verschiedene Rechner sind „um Faktoren“ unterschiedlich schnell (GHz-Klasse)
ƒ Wichtiger ist die ungefähre Größenordnung, mit der der Aufwand in
Abhängigkeit vom Umfang Eingabe wächst.
ƒ Hierbei interessiert vor allem der Aufwand für sehr große Umfänge n.
T(n)
g(n)
f(n)
T(n)
f(n)
g(n)
f,g: Aufwand
unterschiedl.
Algorithmen.
10 Umfang n
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-13
100 Umfang n
M. Philippsen
13.1 Charakterisierung von Aufwänden
O-Kalkül
ƒ Um die Größenordnung des
Aufwandswachstums
festzulegen, wird das
asymptotische Verhalten der
Aufwandsfunktion zumeist mit
einem Repräsentanten einer
bestimmten Funktionsklasse
verglichen.
ƒ Der O-Kalkül erlaubt die
Beschreibung solcher Vergleiche
zwischen Funktionen.
ƒ Edmund Landau, 1877-1938,
deutscher Zahlentheoretiker
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-14
M. Philippsen
13.1 Charakterisierung von Aufwänden
Grundgedanke: Obere Schranken:
ƒ Wir teilen Funktionen, die Aufwand berechnen in Funktionsklassen ein.
„Ignoriere GHz-Klasse“
ƒ Für c, n, n0 ∈ ù
O(f(n)) = { g(n) | ∃c>0 ∃n0>0 ∀n≥n0 : 0 ≤ g(n) ≤ c·f(n) }
Menge!
f,g reellwertig,
asymptotisch
nicht-negativ
sprich: „groß-O“
Ab Umstiegspunkt n0 ist
g(n) kleiner als f(n)
multipliziert mit einer
beliebigen Konstante.
ƒ h(n) ∈ O(f(n)) bedeutet:
y h(n) wächst höchstens so schnell wie f(n).
y Selbst bei einer Multiplikation mit einem beliebig großen Faktor ist h(n) für
große n kleiner als f(n).
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-15
M. Philippsen
13.1 Charakterisierung von Aufwänden
O-Notation (asymptotisch obere Schranke), „groß-O“
ƒ h(n)0O(f(n)): h(n) wächst höchstens so schnell wie f(n)
ƒ Definition:
O(f(n)) = { g(n) | ∃c>0 ∃n0>0 ∀n≥n0 : 0 ≤ g(n) ≤ c·f(n) }
c·f(n)
h(n)
h(n) 0 O(f(n))
n0
n
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-16
M. Philippsen
13.1 Charakterisierung von Aufwänden
O-Notation (asymptotisch obere Schranke), „groß-O“
O(f(n)) = { g(n) | ∃c>0 ∃n0>0 ∀n≥n0 : 0 ≤ g(n) ≤ c·f(n) }
Beispiele:
ƒ Betrachte h(n) = n2+n
y Es gilt n²+n ≤ 2n2.
y In der Menge O(n²) sind (auch) alle Funktionen, deren Wert ab einem n0
unter 2n² sind.
y Daher gilt h(n) = n²+n 0 O(n2)
ƒ Betrachte h(n) = 5n²+15
y Es gilt ab n≥6: 5n² + 15 ≤ 6n² ≤ n3.
y In der Menge O(n3) sind (auch) alle Funktionen, deren Wert ab einem n0
unter 6n² sind.
y Daher gilt h(n) = 5n²+15 0 O(n3)
O-Kalkül gibt
y Es gilt natürlich auch h(n) 0 O(n2)
sehr grobe obere
Schranke an.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-17
M. Philippsen
13.2 Aufwände von Algorithmen
Beispiel (1)
ƒ Gegeben: x, an, an-1, ..., a0
ƒ Gesucht: Pn(x) = anxn + an-1xn-1 + ... + a1x + a0
ƒ Horner-Schema (für Von-Neumann-Rechner):
p = a[n];
for (int i = n-1; i >= 0; i--) p = p * x + a[i];
Die Schleife wird n mal durchlaufen. Jeder
Durchlauf hat konstanten Zeitbedarf.
ƒ Zeitaufwand ist in O(n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-18
M. Philippsen
13.2 Aufwände von Algorithmen
Beispiel (2)
Gegeben:
Aufgabe:
Zeichenfolge A = a1, a2, ..., an
Stelle fest, ob A ein Palindrom ist, d.h.
∀i∈{1...n}: ai = an+1-i
ƒ Algorithmus (für Von-Neumann-Rechner):
for (int i=1; i<=n; i++) {
if (a[i] != a[n+1-i]) {
return false;
}
}
return true;
ƒ Zeitaufwand ist in O(n)
Die Schleife wird
höchstens/im schlimmsten
Fall n mal durchlaufen. Für
jeden Durchlauf kann ein
maximaler, aber
konstanter oberer
Zeitbedarf angegeben
werden.
Bei Fallunterscheidung, in der Regel
Aufwand des teuersten Falls veranschlagen
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-19
M. Philippsen
13.2 Aufwände von Algorithmen
ƒ Implementierungsbeispiel „length“ einer Liste (1)
Liste
class Liste {
...
//rekursiver Ansatz
int length() {
return length(kopf);
}
private int length(Element e) {
if (e == null) return 0;
else return 1+length(e.voriges);
}
}
length wird rekursiv aufgerufen,
dabei wird die Liste jeweils um 1
Element gekürzt. Bei n Elementen
gibt es n Aufrufe. Der Rumpf hat
konstanten maximalen Zeitbedarf
kopf
Element
1+…
3
voriges
2
voriges
1+…
1
1+…
voriges
0
Zeitaufwand ist in O(n).
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-20
M. Philippsen
13.2 Aufwände von Algorithmen
ƒ Implementierungsbeispiel „length“ einer Liste (2)
Liste
class Liste {
...
//entrekursivierte Fassung
int length() {
int len = 0;
Element e = kopf;
while (e != null) {
e = e.voriges;
len += 1;
}
return len;
}
konstanter Aufwand vor und nach
}
der Schleife. Der Schleifenrumpf
hat konstanten Aufwand. Die
Schleife wird für jedes der n
Elemente einmal durchlaufen.
kopf
Element
0, e
voriges
1, e
voriges
2, e
voriges
3, e
Zeitaufwand ist in O(n).
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-21
M. Philippsen
13.2 Aufwände von Algorithmen
ƒ Implementierungsbeispiel „length“ einer Liste (3)
class Liste {
int length
Liste() {...
length = 0; ...
}
Liste append(Element neu) {...
length++;
}
Liste tail() { ...
length--; …
}
int length() {
return length;
}
...
}
Jetzt ist die Listenlänge in
konstanter Zeit O(1) ablesbar.
Dafür fallen bei m Operationen
m Einheiten zusätzlichen
Aufwands an.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-22
M. Philippsen
13.2 Aufwände von Algorithmen
ƒ O-Kalkül dient also der „pi-mal-Daumen-Abschätzung“ des Aufwands
in Abhängigkeit der Problemgröße!
ƒ Ist diese Daumenschätzung aussagekräftig?
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-23
M. Philippsen
13.2 Aufwände von Algorithmen
Illustration am Beispiel (1)
ƒ Aufgabe: Finde in einem Zahlenvektor den Abschnitt, dessen
Elemente addiert, die größte Summe ergeben.
ƒ Hierfür gibt es einen Algorithmus mit O(n3) und einen mit O(n), siehe
Abschnitt 9.12.
Alpha 21164A (533 MHz),
C-Programm, O(n3)-Algo.
Radio Shack TRS-80 (2,03 MHz),
BASIC-Programm, O(n)-Algo.
10
0,58µs
195ms
102
0,58ms
1,95s
103
0,58s
19,5s
104
9min 40s
3min 15s
105
6d 16h 6min 40s
32min 30s
106
18y 142d 23h 6min 40s
5h 25min
n
ƒ Umschlagpunkt bei ca. n=5800 und t=1 min 53 s
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-24
M. Philippsen
13.2 Aufwände von Algorithmen
Illustration am Beispiel (2)
ƒ auf einem Rechner, der 1 Nano-Sekunde (10-9) pro Operation braucht,
dauert die Berechnung von f(n)…
n f(n)=ld n
f(n)=n
f(n)=n·ld n f(n)=n2
f(n)=2n
f(n)=n!
10 0.003 µs 0.01 µs 0.033 µs
0.1 µs
1 µs
3.63 ms
20 0.004 µs 0.02 µs 0.086 µs
0.4 µs
1 ms
77.1 Jahre
30 0.005 µs 0.03 µs 0.147 µs
0.9 µs
1s
8.4·1015 Jahre
40 0.005 µs 0.04 µs 0.213 µs
1.6 µs
18.3 min
50 0.006 µs 0.05 µs 0.282 µs
2.5 µs
13 Tage
100 0.007 µs 0.1 µs
0.644 µs
10 µs
4·1013 Jahre
1 000 0.010 µs 1.0 µs
9.966 µs
1 ms
10 000 0.013 µs 10 µs
130 µs
100 ms
100 000 0.017 µs 0.1 ms
1.67 ms
10 s
19.93 ms
16.7 min
0.23 s
1.16 Tage
1 000 000 0.020 µs 1 ms
10 000 000 0.023 µs 0.01 s
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-25
M. Philippsen
13.2 Aufwände von Algorithmen
Illustration am Beispiel (3)
ƒ Laufzeiten für ein Problem vom Umfang n=1000 auf unterschiedlich
schnellen Rechnern und mit unterschiedlich schnellen Algorithmen
besserer Algorithmus
Laufzeit
Laufzeit
Laufzeit
Aufwand Laufzeit
1000/Sek. 2000/Sek. 4000/Sek. 8000/Sek.
log2n
0.010
0.005
0.003
0.001
1
0.5
0.25
0.125
n·log2n
10
5
2.5
1.25
n1.5
32
16
8
4
n2
1000
500
250
125
n3
1000 000
500 000
250 000
125 000
n
1.1n
1039
1039
1038
1038
schnellerer Rechner
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-26
M. Philippsen
13.2 Aufwände von Algorithmen
Aufwand für ein Problem:
ƒ Verschiedene Algorithmen zur Berechnung von f können bei gleicher
Eingabe unterschiedlichen Aufwand haben.
ƒ Eigentlich interessiert man sich für den Aufwand des Problems und
nicht für den Aufwand eines konkreten Algorithmus
ƒ Daher zwei Aufgaben:
y Bestimme kleinsten möglichen Aufwand für das Problem
= Komplexität des Problems
y Bestimme Algorithmus mit kleinstem möglichen Aufwand
à Dauerbeschäftigung des Algorithmikers,
à auch für uns in weiten Teilen der Vorlesung!
ƒ Auf den tatsächlichen Aufwand haben auch Einfluss:
y Programmiersprache
y Rechnerorganisation
y Prozessorgeschwindigkeit
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-27
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Rechenregeln (1)
Erinnerung:
O(f(n)) = { g(n) | ∃c>0 ∃n0>0 ∀n≥n0 : 0 ≤ g(n) ≤ c·f(n) }
ƒ Seien f(n) 0 O(r(n))
f(n) + g(n)
f(n) · g(n)
c · f(n)
f(n) ± c
und g(n) 0 O(s(n)), c>0 konstant. Dann
0 O(r(n) + s(n))
0 O(r(n) · s(n))
0 O(r(n))
0 O(r(n))
Konstante ±c muss rechts
ƒ Exemplarische Beweis-Skizze:
von f(n) stehen, wegen
„asymptotisch nicht-negativ“
y Es gibt Konstanten c1, n1, c2, n2, so dass f(n)≤c1·r(n) für n>n1 und
g(n)≤c2·s(n) für n>n2.
y Mit dem größeren ci und dem größeren nj können die ersten beiden obigen
Rechenregeln gezeigt werden.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-28
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Rechenregeln (2)
ƒ Entsprechende Regel für Subtraktion gilt nicht.
Exemplarisches Gegenbeispiel:
y f(n) = 2n2 0 O(n2)
y g(n) = n2 0 O(n2)
y f(n)-g(n) = 2n2 - n2 = n2 0 O(n2)
aber:
ó O(n2-n2)=O(0)
ƒ Entsprechende Regel für Division gilt nicht.
Es gilt nur:
f(n) / g(n)
0 O(r(n) / g(n))
nicht: s(n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-29
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Rechenregeln (3)
ƒ Bei O(log n) kann man auf die Basis des Logarithmus verzichten, da
der Wechsel der Basis nur eine konstante Verschiebung ausmacht.
ƒ Für c>0 und a>1 und f(n) monoton steigend gilt: fc(n) 0 O(af(n)).
Exponentielle Funktionen wachsen stärker als polynomielle Funktionen
Beispiele:
y nc 0 O(an)
y (logan)c 0 O(alogan) = O(n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-30
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Anmerkungen zum „Einweg-Gleichheitszeichen“
ƒ In der Literatur findet man oft statt f 0 O(g) eine Schreibweise mit
Gleichheitszeichen: f = O(g).
ƒ Die rechte Seite O(g) enthält viel mehr Informationen als die linke.
Man muss daher beim Lesen 0 oder f denken.
ƒ Die Tatsache, dass auf der rechten Seite eine Menge steht wird
dabei verborgen.
y Quelle vieler Fehler!
y Achtung: das Gleichheitszeichen kann man in diesem Fall nur in eine
Richtung lesen: Die „Rückrichtung“ gilt nicht: O(g)≠f
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-31
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Rechenregeln (4)
ƒ Erweiterung: arithmetische Operationen auf Funktionenklasse
ƒ Es gilt (für Funktionen f,g und Konstante c>0):
y c · O(f) = O(c · f) = O(f)
y O(f) · O(g) = O(f · g)
y O(f · g) = f · O(g)
y O(O(f)) = O(f)
„Für jede Konstante und jeden
Umstiegspunkt auf der linken Seite
gibt es eine Konstante und einen
Umstiegspunkt für die rechte Seite.“
aber natürlich nicht: O(f) = f
y O(f) ± c = O(f ± c) = O(f)
y O(f) + O(f) = O(f)
y O(f+g) = O(max(f,g))
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-32
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Beweis von O(f+g) = O(max(f, g))
ƒ Richtung f:
y Sei t(n) 0 O(f(n)+g(n)).
y Dann gibt es ein c0ú+ und ein n00ù, so dass für alle n>n0 gilt
t(n) ≤ c · (f(n)+g(n))
y Nach Def. von max:
≤ 2 · c · max(f(n), g(n))
y Mit c‘ = 2 · c gilt für alle n>n0 damit
t(n) ≤ c‘ · max(f(n), g(n))
Also ist t(n) 0 O(max(f(n), g(n)))
ƒ Richtung g:
y Sei t(n) 0 O(max(f(n), g(n))).
y Dann gibt es ein c0ú+ und ein n00ù, so dass für alle n>n0 gilt
t(n) ≤ c · max(f(n), g(n))
y Nach Def. von max:
≤ c · (f(n)+g(n))
y Also ist t(n) 0 O(f(n)+g(n))
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-33
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Beispiele
0 O(83 + 17 * n)
//obige Rechenregel
= O(17 * n)
//obige Rechenregel
= 17 * O(n)
//obige Rechenregel
= O(n)
//obige Rechenregel
ƒ anxn + an-1xn-1+ an-2xn-2 + … + a0 = O(xn)
Beweis durch vollständige Induktion:
ƒ 83 + 17*n
y Induktionsanfang „n=0“: a0 0 O(a0) = a0 * O(1) = O(x0)
y Induktionsschritt „n-1Æn“:
anxn + an-1xn-1+ an-2xn-2 + … + a0
0 O(x * (anxn-1 + an-1xn-2 + … + a1) + a0)
= O(x * (anxn-1 + an-1xn-2 + … + a1))
= O(x) * O(anxn-1 + an-1xn-2 + … + a1)
= O(x) * O(xn-1)
//Induktionsvoraussetzung
= O(xn)
q.e.d.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-34
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
ƒ Das O-Kalkül gibt eine sehr grobe obere Schranke an.
y Alle Algorithmen, die wir bisher kennen gelernt haben sind in O(2n), sie
brauchen also nicht mehr als exponentiellen Zeitaufwand.
ƒ Weitere Abschätzungen sind nötig
y engere Grenze nach oben
y Untere Schranken
ƒ Donald Knuth: Meist wird mit Aufwand im O-Kalkül argumentiert, man
meint dabei aber eigentlich die kleinste obere Schranke.
Æ Dafür gibt es andere Funktionsklassen...
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-35
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
o-Notation (obere Schranke), „klein-o“
ƒ h(n) 0 o(f(n)): h(n) wächst deutlich langsamer als f(n)
Jetzt nicht wie bei O „es gibt irgendeine Konstante“,
ƒ Definition:
sondern „egal für welche Konstante“.
o(f(n)) = { g(n) | ∀c>0 ∃n0>0 ∀n≥n0 : 0 ≤ g(n) < c·f(n) }
c·f(n)
h(n) 0 o(f(n))
h(n)
n0
n
Anders ausgedrückt: es gilt also: limnÆ∞ h(n) / f(n) = 0
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-36
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
o-Notation (obere Schranke), „klein-o“
o(f(n)) = { g(n) | ∀c>0 ∃n0>0 ∀n≥n0 : 0 ≤ g(n) < c·f(n) }
Beispiele:
ƒ 2·n 0 o(n2)
2·n wächst deutlich langsamer als n². Für jede Konstante c>0 kann
also ein n0 angegeben werden, so dass ab n0 gilt: c·n² > 2·n.
ƒ 2·n2 ó o(n2)
2·n² wächst dagegen nicht deutlich langsamer als n². Z.B. kann für die
Konstante c=1 kein n0 angegeben werden, so dass ab n0 gilt:
n² > 2·n².
Während O gewissermassen ≤ zum Ausdruck bringt, steht o für <.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-37
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Ω-Notation (asymptotisch untere Schranke), „groß-Omega“
ƒ h(n) 0 Ω(f(n)): h(n) wächst mindestens so schnell wie f(n)
ƒ Definition:
Ω(f(n)) = { g(n) | ∃c>0 ∃n0>0 ∀n≥n0 : 0 ≤ c·f(n) ≤ g(n) }
h(n)
h(n) 0 Ω(f(n))
c·f(n)
n0
Beispiele:
5·n2+42·n+2 0 Ω(n2)
ó Ω(n3)
n
2n+5·n 0 Ω(2n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-38
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
ω-Notation (untere Schranke), „klein-omega“
ƒ h(n) 0 ω(f(n)): h(n) wächst deutlich schneller als f(n)
ƒ Definition:
ω(f(n)) = { g(n) | ∀c>0 ∃n0>0 ∀n≥n0 : 0 ≤ c·f(n) < g(n) }
h(n)
h(n) 0 ω(f(n))
c·f(n)
n0
n
Anders ausgedrückt: Es gilt also: limnÆ∞ h(n) / f(n) = ∞
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-39
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
ω-Notation (untere Schranke), „klein-omega“
ω(f(n)) = { g(n) | ∀c>0 ∃n0>0 ∀n≥n0 : 0 ≤ c·f(n) < g(n) }
Beispiele:
• n2/2 0 ω(n)
• n2/2 ó ω(n2)
• Während Ω gewissermaßen ≥ zum Ausdruck bringt, steht ω für >.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-40
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Θ-Notation (asymptotisch gebunden), „groß-Theta“
ƒ h(n) 0 Θ(f(n)): h(n) wächst ebenso schnell wie f(n)
ƒ Definition:
Θ(f(n)) = { g(n) | ∃c1>0 ∃c2>0 ∃n0>0
∀n≥n0 : 0 ≤ c1·f(n) ≤ g(n) ≤ c2·f(n) }
c2·f(n)
h(n)
h(n) 0 Θ(f(n))
c1·f(n)
n0
Beispiele:
a·n2 + b·n 0 Θ(n2)
n
a·n2 ó Θ(n)
a·n2 ó Θ(n3)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-41
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Rechenregeln (5)
ƒ “Sandwich-Gedanke”:
f(n) 0 Θ(g(n)) genau dann, wenn f(n) 0 O(g(n)) und f(n) 0 Ω(g(n)).
ƒ Symmetrie:
y f(n) 0 Θ(g(n)) genau dann, wenn g(n) 0 Θ(f(n))
y Beweisskizze:
„Y:“
„Z:“
Es gibt c1>0, c2>0, n0>0 so dass für alle n>n0 gilt:
0 ≤ c1·g(n) ≤ f(n) ≤ c2·g(n)
Damit gilt auch
0 ≤ f(n)/c2 ≤ g(n)
0 ≤ g(n) ≤ f(n)/c1 und
analog
y Keine Symmetrieeigenschaft: O, o, Ω, ω
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-42
M. Philippsen
13.3 Charakterisierung von Aufwänden, Fortsetzung
Rechenregeln (6)
ƒ f(n) 0 O(g(n)) genau dann, wenn g(n) 0 Ω(f(n))
Informell:
f wächst höchstens so schnell wie g
= g wächst mindestens so schnell wie f
ƒ f(n) 0 o(g(n)) genau dann, wenn g(n) 0 ω(f(n))
Informell:
f wächst deutlich langsamer als g
= g wächst deutlich schneller als f.
ƒ Reflexivität:
y f(n) 0 Θ(f(n)), f(n) 0 O(f(n)),
y Keine Reflexivität: o und ω
f(n) 0 Ω(f(n))
ƒ Transitivität:
y Wenn f(n) 0 O(g(n)) und g(n) 0 O(h(n)), dann f(n) 0 O(h(n)).
y Auch transitiv: o, Ω, ω, Θ
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-43
M. Philippsen
13.2 Aufwände von Algorithmen
Einfluss des Maschinenmodells auf den Aufwand
ƒ Der Aufwand eines Algorithmus hängt von der zugrundeliegenden
Rechnerarchitektur ab.
Bisher Random Access Machine (RAM), Von-Neumann-Rechner
ƒ Dient in der Regel als Maschinenmodell für Aufwandsberechnungen:
y ein Prozessor
y Hauptspeicher unbeschränkt groß
y Speicherzelle unbeschränkt lang
y eine Zeiteinheit je elementarer Operation
ai
ai+1
ai+2
...
aj-1
aj
...
Rechenwerk
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-44
M. Philippsen
13.2 Aufwände von Algorithmen
Die Turing-Maschine
wird in der theoretischen
Informatik vertieft.
Turing-Maschine
ƒ (Potentiell) unendliches Band mit Feldern
ƒ Genau ein Zeichen je Feld
ƒ Ein Schreib-/Lesekopf bewegt sich über das Band.
ƒ Nur das Zeichen, auf dem der Lesekopf steht, kann im nächsten
Rechenschritt verändert werden.
ƒ Der Kopf kann in einem Rechenschritt ein Feld nach links oder ein
Feld nach rechts bewegt werden.
ai
ai+1
ai+2
...
aj-1
aj
Rechenwerk
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-45
M. Philippsen
13.2 Aufwände von Algorithmen
Aufwand hängt vom Maschinenmodell ab (1)
ƒ Palindrom-Algorithmus für Turing-Maschine:
Kopfbewegungen
Aufwand in O(n2)
a1
a2
a3
...
an-1
an
Rechenwerk
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-46
M. Philippsen
13.2 Aufwände von Algorithmen
Aufwand hängt vom Maschinenmodell ab (2)
ƒ Palindrom-Algorithmus für 2-Kopf-Turing-Maschine:
Kopfbewegungen
1
2
a1
Aufwand in O(n)
a2
a3
...
an-1
an
Rechenwerk
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-47
M. Philippsen
13.4 Rekurrenzen
Rekurrenzen
ƒ Wenn ein Algorithmus sich selbst rekursiv aufruft, kann seine Laufzeit
oft mit einer Rekurrenz beschrieben werden.
ƒ Eine Rekurrenz ist eine Gleichung oder Ungleichung, bei der der
Funktionswert in Form von Funktionswerten für kleinere Eingabewerte
beschrieben wird.
ƒ Einen allgemeinen Algorithmus zur Lösung einer Rekurrenz gibt es
nicht.
ƒ Beispiel Rekurrenz des Skyline-Problems, Abschnitt 8.5
T(1) = 1
Ergebnis
T(n) = 2 · T(n/2) + n
zusammenbauen
Liste in zwei
Hälften aufteilen
In Abschnitt 8.5 erarbeitete
Lösung der Rekurrenz:
T(n) = n + n.log2(n) 0 O(n.log2(n))
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-48
M. Philippsen
13.4 Rekurrenzen
Lösen von Rekurrenzrelationen: Abschätzungsmethode (1)
ƒ Eine Rekurrenz lässt sich lösen, indem eine Lösung „erraten“ wird:
y Berechne T(n) für einige n.
y Schätze geschlossene Form für T(n) (oder ggf. nur Schranke).
y Beweise (Induktion?), dass das geschätzte T(n) korrekt ist.
ƒ Beispiel:
Für n als 2er Potenz: T(n) = 2·T(n/2) + 4 und T(1) = 1
T(1)
=
1
=
1
+5
T(2)
=
4+2·1 =
6
+10=2·5
T(4)
=
4+2·6 =
16
+20=4·5
T(8)
=
4+2·16 =
36
+40=8·5
T(16)
=
4+2·36 =
76
= 5·1-4
= 5·2-4
= 5·4-4
= 5·8-4
= 5·16-4
Daher Vermutung:
T(n) = 5 · n - 4 0 O(n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-49
M. Philippsen
13.4 Rekurrenzen
Lösen von Rekurrenzrelationen: Abschätzungsmethode (2)
ƒ Eine Rekurrenz lässt sich lösen, indem eine Lösung „erraten“ wird:
y Berechne T(n) für einige n.
y Schätze geschlossene Form für T(n) (oder ggf. nur Schranke).
y Beweise (Induktion?), dass das geschätzte T(n) korrekt ist.
ƒ Beispiel:
Für n als 2er-Potenz: T(n) = 2·T(n/2) + 4 und T(1) = 1,
Vermutung: T(n) = 5·n-4 0 O(n)
Beweis
y Induktionsanfang n=1:
T(1) = 1 = 5 · 1 - 4
y Induktionsschluss (n/2Æn):
T(n)
= 2 · T(n/2) + 4
= 2 · (5 · n/2 - 4) + 4
=5·n-4
//q.e.d.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-50
M. Philippsen
13.4 Rekurrenzen
Abschätzungsmethode am Fibonacci-Beispiel (1)
ƒ fib(n) = fib(n-1) + fib(n-2)
ƒ fib(1) = fib(2) = 1
ƒ 1. Versuch:
Da der Wert von fib die Summe der beiden vorhergehenden Werte
ist, ist eine plausible Annahme, dass fib jedesmal verdoppelt wird.
Daher Versuch: fib(n) = c · 2n
ƒ Das ist aber falsch!
Wegen
fib(n) = fib(n-1) + fib(n-2)
c · 2n = c · 2n-1 + c · 2n-2
2n
= 2n-1
+ 2n-2
4
=2
+1
müsste gelten
//falsch!
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-51
M. Philippsen
13.4 Rekurrenzen
Abschätzungsmethode am Fibonacci-Beispiel (2)
ƒ fib(n) = fib(n-1) + fib(n-2)
ƒ fib(1) = fib(2) = 1
ƒ 2. Versuch:
Statt fib(n) = c · 2n versuche fib(n) = c · an
ƒ Aus fib(n)
an
a2
Y a1
= fib(n-1) + fib(n-2)
= an-1
+ an-2
=a+1
= ½ (1 + √5) w
ergibt sich
a2 = ½ (1 - √5)
ƒ Per Induktion lässt sich zeigen:
fib(n) 0 O(a1n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-52
M. Philippsen
13.4 Rekurrenzen
Abschätzungsmethode am Fibonacci-Beispiel (3)
ƒ fib(n) = fib(n-1) + fib(n-2)
ƒ fib(1) = fib(2) = 1
ƒ 2. Versuch, Fortsetzung zur exakten Lösung
Mit fib(n) = c1 · a1n + c2 · a2n lassen sich aus den Startwerten die
Konstanten c1 und c2 bestimmen. Löse dazu das Gleichungssystem
1 = c1 · a1 + c2 · a2
1 = c1 · a12 + c2 · a22
ƒ Es ergeben sich c1 = 1/√5 und c2 = -1/√5
ƒ Damit
1
1
n
fib(n) =
((½ (1+ √5)) ( ½ (1- √5))n )
√5
√5
ƒ Diese Technik ist anwendbar für alle Rekurrenzen der Form
F(n) = b1 F(n-1) + b2 F(n-2) + ... + bk F(n-k)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-53
M. Philippsen
13.4 Rekurrenzen
Abschätzungsmethode am Teile-und-Herrsche-Beispiel (1)
ƒ Betrachte für n 2er-Potenz, also n=2k:
T(2)=1
T(2n) ≤ 2T(n)+2n-1
ƒ Gesucht ist f(n), so dass T(n) 0 O(f(n)).
ƒ
ƒ
ƒ
ƒ
Erraten: f(n) = n2, T(n)0O(n2). Nachweis per Induktion
Induktionsanfang: T(2) = 1 ≤ 4 = 22
Induktionshypothese: T(n) ≤ n2, für n>0
Induktionsschluss („nÆ2n“):
T(2n)
≤ 2T(n) + 2n - 1
≤ 2 n2 + 2n - 1
≤ 2 n2 + 2 n2
= (2n)2
//Rekurrenz
//Induktionsvoraussetzung
//grobe Abschätzung nach oben
q.e.d.
Gibt es keine bessere obere Schranke?
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-54
M. Philippsen
13.4 Rekurrenzen
Abschätzungsmethode am Teile-und-Herrsche-Beispiel (2)
ƒ Betrachte für n 2er-Potenz, also n=2k:
T(2)=1
T(2n) ≤ 2T(n)+2n-1
ƒ Gesucht ist f(n), so dass T(n) 0 O(f(n)).
ƒ
ƒ
ƒ
ƒ
Erraten: f(n) = n log2n, T(n)0O(n log2n). Nachweis per Induktion
Induktionsanfang: T(2) = 1 ≤ 2 = 2 log2(2)
Induktionshypothese: T(n) ≤ n log2n, für n>0
Induktionsschluss („nÆ2n“):
T(2n)
≤ 2T(n) + 2n - 1
≤ 2n log2n + 2n - 1
≤ 2n (log2n +1)
= 2n (log2n + log22)
= 2n log2(2n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-55
//Rekurrenz
//Induktionsvoraussetzung
//leichte Abschätzung nach oben
//log2
q.e.d.
Was gilt für
Nicht-2er-Potenzen?
M. Philippsen
13.4 Rekurrenzen
Abschätzungsmethode am Teile-und-Herrsche-Beispiel (3)
ƒ Betrachte für alle n:
T(2)=1
T(2n) ≤ 2T(n)+2n-1
ƒ Gilt T(n) 0 O(n log2n) auch für Nicht-2er-Potenzen?
Annahme: 2k-1 < n < 2k
T(n)
≤ T(2k)
≤ c1 2k log2(2k)
≤ c1 2n log2(2n)
≤ c2 n log2n
= O(n log2n)
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-56
//Monotonie von T
//Definition O, c1 Konstante
//2k < 2n
//c2 Konstante
q.e.d.
Fazit: In den meisten Fällen reicht
die Betrachtung von 2er-Potenzen.
M. Philippsen
13.4 Rekurrenzen
Allgemeine Lösung für Teile-und-Herrsche-Probleme (1)
ƒ Teile-und-Herrsche-Probleme lassen sich im allgemeinen durch eine
Rekurrenz der Form
T(n) = a · T(n/b) + f(n)
charakterisieren, wobei a ≥ 1 und b ≥ 1 und f(n) eine Funktion über ù.
ƒ Beispiel: Beim Skyline-Problem betrachteten wir die Rekurrenz
T(n) = 2 T(n/2) + n. Als Lösung hatten wir n+n·log2n ermittelt.
ƒ Es gibt eine allgemeine Lösung für derartige Rekurrenzen,
y die in der Theoretischen Informatik erläutert und bewiesen wird
y die im Sinne einer Formelsammlung benutzt werden, um den Aufwand
von Teile-und-Herrsche-Algorithmen zu ermitteln.
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-57
M. Philippsen
13.4 Rekurrenzen
Allgemeine Lösung für Teile-und-Herrsche-Probleme (2)
Hauptsatz über lineare Rekurrenzen
Sei a ≥ 1 und b ≥ 1, sei f(n) eine Funktion und T(n) gegeben
durch die Rekurrenz
T(n) = a · T(n/b) + f(n)
Dann ist T(n) asymptotisch beschränkt durch:
ƒ Wenn f(n)0O(nlogba-ε) für ε>0, dann T(n) 0 Θ(nlogba).
ƒ Wenn f(n)0Θ(nlogba),
dann T(n) 0 Θ(nlogba · log2 n).
ƒ Wenn f(n)0Ω(nlogba+ε) für ε>0 und wenn a · f(n/b) ≤ c · f(n) für c < 1 und
genügend große n,
dann T(n) 0 Θ(f(n)).
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-58
M. Philippsen
13.4 Rekurrenzen
Beispiele zur Anwendung des Hauptsatzes über Rekurrenzen (1)
Sei a ≥ 1 und b ≥ 1, sei f(n) eine Funktion und T(n) gegeben durch
T(n) = a · T(n/b) + f(n)
Dann ist T(n) asymptotisch beschränkt durch:
ƒ
ƒ
ƒ
Wenn f(n)0O(nlogba-ε) für ε>0,
dann T(n) 0 Θ(nlogba).
Wenn f(n)0Θ(nlogba),
dann T(n) 0 Θ(nlogba · log2 n).
Wenn f(n)0Ω(nlogba+ε) für ε>0 und wenn a · f(n/b) ≤ c · f(n) für c < 1 und
genügend große n,
dann T(n) 0 Θ(f(n)).
T(n) = 9·T(n/3) + n
Somit a=9, b=3, f(n) = n
nlogba = nlog39 = n2.
Da f(n) 0 O(nlog39-ε) mit ε=1, wird der erste Fall erfüllt und daher
ergibt sich T(n) 0 Θ(n2).
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-59
M. Philippsen
13.4 Rekurrenzen
Beispiele zur Anwendung des Hauptsatzes über Rekurrenzen (2)
Sei a ≥ 1 und b ≥ 1, sei f(n) eine Funktion und T(n) gegeben durch
T(n) = a · T(n/b) + f(n)
Dann ist T(n) asymptotisch beschränkt durch:
ƒ
ƒ
ƒ
Wenn f(n)0O(nlogba-ε) für ε>0,
dann T(n) 0 Θ(nlogba).
Wenn f(n)0Θ(nlogba),
dann T(n) 0 Θ(nlogba · log2 n).
Wenn f(n)0Ω(nlogba+ε) für ε>0 und wenn a · f(n/b) ≤ c · f(n) für c < 1 und
genügend große n,
dann T(n) 0 Θ(f(n)).
T(n) = 3·T(n/4) + n log2 n
Somit a=3, b=4, f(n) = n log2 n
nlogba = nlog43 ≈ n0,793.
Da f(n) 0 Ω(nlog43+ε) mit ε≈0,2 wird der dritte Fall erfüllt. Noch zu
zeigen, dass für genügend große n die Bedingung erfüllt ist.
a·f(n/b) = 3·(n/4)log2(n/4) ≤ (3/4)·n·log2 n = c·f(n) mit c=3/4 gilt
für große n und daher ergibt sich T(n) 0 Θ(n·log2 n).
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-60
M. Philippsen
13.4 Rekurrenzen
Nützliche Formeln zur Aufwandsanalyse
ƒ 1+2+3+…+n = ½ n (n+1)
ƒ 1+2+4+…+2n = 2n+1 - 1
ƒ 1+4+9+…+n2 = 1/6 n (n+1) (2n+1)
ƒ
ƒ
ƒ
ƒ
logba = 1/logab
logax = logbx / logba
blogbx = x
blogax = xlogab
n
ƒ ∑ llog2im 0 Θ(n log2 n)
i=1
Friedrich-Alexander-Universität Erlangen-Nürnberg
Algorithmik 1, WS 2004/05, Folie 13-61
M. Philippsen
Herunterladen
Explore flashcards