Algorithmen - informatik.uni

Algorithmen
Markus Lohrey
Universität Siegen
Wintersemester 2013/2014
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
1 / 84
Überblick, Literatur
Überblick:
1
Grundlegendes
2
Divide & Conquer
3
Sortieren
4
Greedyalgorithmen
5
Dynamische Programmierung
6
Graphalgorithmen
Literatur:
Cormen, Leiserson Rivest, Stein. Introduction to Algorithms (3.
Auflage); MIT Press 2009
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
2 / 84
Grundlegendes
Landau Symbole
Seien f , g : N → N Funktionen.
Es gilt g ∈ O(f ), falls
∃c > 0 ∃n0 ∀n ≥ n0 : g (n) ≤ c · f (n).
Also: g wächst nicht schneller als f .
Es gilt g ∈ o(f ), falls
∀c > 0 ∃n0 ∀n ≥ n0 : g (n) ≤ c · f (n).
Also: g wächst echt langsamer als f .
g ∈ Ω(f ) ⇔ f ∈ O(g )
Also: g wächst mindestens so schnell wie f .
g ∈ ω(f ) ⇔ f ∈ o(g )
Also: g wächst echt schneller als f .
g ∈ Θ(f ) ⇔ (f ∈ O(g ) ∧ g ∈ O(f ))
Dies heißt, g und f wachsen asymptotisch gleichschnell.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
3 / 84
Grundlegendes
Komplexitätsmaße
Wir beschreiben die Laufzeit eines Algorithmus A als eine Funktion in
Abhängigkeit von der Eingabelänge n.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
4 / 84
Grundlegendes
Komplexitätsmaße
Wir beschreiben die Laufzeit eines Algorithmus A als eine Funktion in
Abhängigkeit von der Eingabelänge n.
Standard: Komplexität im ungünstigsten Fall (worst case).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
4 / 84
Grundlegendes
Komplexitätsmaße
Wir beschreiben die Laufzeit eines Algorithmus A als eine Funktion in
Abhängigkeit von der Eingabelänge n.
Standard: Komplexität im ungünstigsten Fall (worst case).
Maximale Laufzeit über alle Eingaben der Länge n:
tA,worst (n) = max{tA (x) | x ∈ Xn },
wobei Xn = {x | |x| = n}.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
4 / 84
Grundlegendes
Komplexitätsmaße
Wir beschreiben die Laufzeit eines Algorithmus A als eine Funktion in
Abhängigkeit von der Eingabelänge n.
Standard: Komplexität im ungünstigsten Fall (worst case).
Maximale Laufzeit über alle Eingaben der Länge n:
tA,worst (n) = max{tA (x) | x ∈ Xn },
wobei Xn = {x | |x| = n}.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
4 / 84
Grundlegendes
Komplexitätsmaße
Wir beschreiben die Laufzeit eines Algorithmus A als eine Funktion in
Abhängigkeit von der Eingabelänge n.
Standard: Komplexität im ungünstigsten Fall (worst case).
Maximale Laufzeit über alle Eingaben der Länge n:
tA,worst (n) = max{tA (x) | x ∈ Xn },
wobei Xn = {x | |x| = n}.
Kritik: Unrealistisch, da Worst-Case Eingaben in der Praxis häufig nicht
auftreten.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
4 / 84
Grundlegendes
Komplexitätsmaße
Alternative: Komplexität im Mittel (average case).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
5 / 84
Grundlegendes
Komplexitätsmaße
Alternative: Komplexität im Mittel (average case).
Benötigt eine Wahrscheinlichkeitsverteilung auf der Menge Xn .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
5 / 84
Grundlegendes
Komplexitätsmaße
Alternative: Komplexität im Mittel (average case).
Benötigt eine Wahrscheinlichkeitsverteilung auf der Menge Xn .
Standard: Gleichverteilung, d.h. Prob(x) =
Markus Lohrey (Universität Siegen)
Algorithmen
1
|Xn | .
WS 2013/2014
5 / 84
Grundlegendes
Komplexitätsmaße
Alternative: Komplexität im Mittel (average case).
Benötigt eine Wahrscheinlichkeitsverteilung auf der Menge Xn .
Standard: Gleichverteilung, d.h. Prob(x) =
Mittlerer Zeitbedarf:
tA,Mittel (n) =
X
x∈Xn
=
1
|Xn | .
Prob(x) · tA (x)
1 X
tA (x)
|Xn |
(bei Gleichverteilung)
x∈Xn
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
5 / 84
Grundlegendes
Komplexitätsmaße
Alternative: Komplexität im Mittel (average case).
Benötigt eine Wahrscheinlichkeitsverteilung auf der Menge Xn .
Standard: Gleichverteilung, d.h. Prob(x) =
Mittlerer Zeitbedarf:
tA,Mittel (n) =
X
x∈Xn
=
1
|Xn | .
Prob(x) · tA (x)
1 X
tA (x)
|Xn |
(bei Gleichverteilung)
x∈Xn
Problem: Häufig schwer zu analysieren.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
5 / 84
Grundlegendes
Komplexitätsmaße
Alternative: Komplexität im Mittel (average case).
Benötigt eine Wahrscheinlichkeitsverteilung auf der Menge Xn .
Standard: Gleichverteilung, d.h. Prob(x) =
Mittlerer Zeitbedarf:
tA,Mittel (n) =
X
x∈Xn
=
1
|Xn | .
Prob(x) · tA (x)
1 X
tA (x)
|Xn |
(bei Gleichverteilung)
x∈Xn
Problem: Häufig schwer zu analysieren.
Beispiel: Quicksort
Beim Quicksort-Algorithmus ist die Anzahl der Vergleiche im
ungünstigsten Fall tQ (n) ∈ Θ(n2 ).
Mittlerer Anzahl der Vergleiche: tQ,Mittel (n) = 1.38n log n
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
5 / 84
Grundlegendes
Maschinenmodelle: Turingmaschine
Die Turingmaschine (TM) ist ein mathematisch leicht exakt
beschreibbares Berechnungsmodell.
Aber: Der zeitraubende Speicherzugriff (Bandzugriff) in der Realität nicht
gegeben.
Arbeitet ein Algorithmus auf einer TM schnell, so ist er schnell!
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
6 / 84
Grundlegendes
Maschinenmodelle: Registermaschine (RAM)
x1 x2 x3 x4 x5 x6 x7 x8 x9
.
.
.
Eingabe READ ONLY
Speicher
RAM
0 = Akku
1 = 1.Reg
2 = 2.Reg
3 = 3.Reg
4 = 4.Reg
IC
-
.
Programm
.
.
y1 y2 y3 y4 y5 y6 y7 y8 y9
.
.
.
Ausgabe WRITE ONLY
Annahme: Elementare Registeroperationen (z.B. arithmetische
Operationen +, ×, −, DIV, Vergleiche, bitweises UND bzw. ODER)
können in einem Rechenschritt durchgeführt werden.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
7 / 84
Divide & Conquer
Überblick
Lösen von Rekursionsgleichungen
Mergesort
Schnelle Multiplikation ganzer Zahlen
Matrixmultiplikation nach Strassen
Schnelle Fourier Transformation
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
8 / 84
Divide & Conquer
Divide & Conquer: Grundidee
Als erstes zentrales Entwurfsprinzip für Algorithmen wollen wir Divide &
Conquer kennenlernen:
Grundidee:
Zerlege die Eingabe in mehrere (meistens ungefähr gleich große) Teile
Löse das Problem auf jedem Teil der Eingabe separat (Rekursion!)
Füge die Teillösungen zu einer Gesamtlösung zusammen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
9 / 84
Divide & Conquer
Rekursionsgleichungen
Divide & Conquer führt auf natürliche Weise zu Rekursionsgleichungen.
Annahmen:
Eingabe der Länge n wird in a viele Teile der Größe n/b zerlegt.
Zerlegen sowie Zusammenfügen der Teillösungen benötigt Zeit g (n).
Für eine Eingabe der Länge 1 beträgt die Rechenzeit g (1).
Dies führt für die Rechenzeit zu folgender Rekursionsgleichung:
t(1) = g (1)
t(n) = a · t(n/b) + g (n)
Technisches Problem: Was, wenn n nicht durch b teilbar ist?
Lösung 1: Ersetze n/b durch ⌈n/b⌉.
Lösung 2: Wir setzen voraus, dass n = b k für ein k ≥ 0.
Falls dies nicht erfüllt ist: Strecke die Eingabe (Für jede Zahl n
existiert ein k ≥ 0 mit n ≤ b k < bn).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
10 / 84
Divide & Conquer
Lösen einfacher Rekursionsgleichungen
Theorem 1
Seien a, b ∈ N und b > 1, g : N −→ N und es gelte die
Rekursionsgleichung:
t(1) = g (1)
t(n) = a · t(n/b) + g (n)
Dann gilt für n = b k (d.h. für k = logb (n)):
t(n) =
k
X
i =0
ai · g
n
Markus Lohrey (Universität Siegen)
bi
.
Algorithmen
WS 2013/2014
11 / 84
Divide & Conquer
Lösen einfacher Rekursionsgleichungen
Theorem 1
Seien a, b ∈ N und b > 1, g : N −→ N und es gelte die
Rekursionsgleichung:
t(1) = g (1)
t(n) = a · t(n/b) + g (n)
Dann gilt für n = b k (d.h. für k = logb (n)):
t(n) =
k
X
i =0
ai · g
n
bi
.
Beweis: Induktion über k.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
11 / 84
Divide & Conquer
Lösen einfacher Rekursionsgleichungen
Theorem 1
Seien a, b ∈ N und b > 1, g : N −→ N und es gelte die
Rekursionsgleichung:
t(1) = g (1)
t(n) = a · t(n/b) + g (n)
Dann gilt für n = b k (d.h. für k = logb (n)):
t(n) =
k
X
i =0
ai · g
n
bi
.
Beweis: Induktion über k.
k = 0 : Es gilt n = b 0 = 1 und t(1) = g (1).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
11 / 84
Divide & Conquer
Lösen einfacher Rekursionsgleichungen
k > 0 : Nach Induktion gilt
t
Also:
t(n) = a · t
= a
n
b
k−1
X
i =0
=
=
k
X
i =1
k
X
i =0
b
=
k−1
X
i =0
ai · g
ai · g
n .
b i +1
+ g (n)
n ai · g
b i +1
ai · g
Markus Lohrey (Universität Siegen)
n
n
bi
n
bi
!
+ a0 g
+ g (n)
n
b0
.
Algorithmen
WS 2013/2014
12 / 84
Divide & Conquer
Mastertheorem I
Theorem 2 (Mastertheorem I)
Seien a, b, d ∈ N, mit b > 1 und es gelte die Rekursionsgleichung:
t(1) = 1
t(n) = a · t(n/b) + d · nc
Dann gilt für alle n der Form b k mit k ≥ 0:

c

falls a < b c
 Θ(n )
Θ(nc log n) falls a = b c
t(n) ∈
log a

 Θ(n log
b)
falls a > b c
Bemerkung:
log a
log b
= logb a. Falls a > b c , so ist logb a > c.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
13 / 84
Divide & Conquer
Beweis Mastertheorem I
Sei g (n) = dnc . Damit gilt nach Theorem 1 mit k = logb n:
t(n) = d · nc ·
Markus Lohrey (Universität Siegen)
k X
a i
.
bc
i =0
Algorithmen
WS 2013/2014
14 / 84
Divide & Conquer
Beweis Mastertheorem I
Sei g (n) = dnc . Damit gilt nach Theorem 1 mit k = logb n:
t(n) = d · nc ·
k X
a i
.
bc
i =0
1. Fall: a < b c
∞ X
1
a i
= d · nc ·
∈ O(nc ).
t(n) ≤ d · n ·
c
b
1 − bac
c
i =0
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
14 / 84
Divide & Conquer
Beweis Mastertheorem I
Sei g (n) = dnc . Damit gilt nach Theorem 1 mit k = logb n:
t(n) = d · nc ·
k X
a i
.
bc
i =0
1. Fall: a < b c
∞ X
1
a i
= d · nc ·
∈ O(nc ).
t(n) ≤ d · n ·
c
b
1 − bac
c
i =0
Außerdem gilt t(n) ∈ Ω(nc ). Hieraus folgt t(n) ∈ Θ(nc ).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
14 / 84
Divide & Conquer
Beweis Mastertheorem I
Sei g (n) = dnc . Damit gilt nach Theorem 1 mit k = logb n:
t(n) = d · nc ·
k X
a i
.
bc
i =0
1. Fall: a < b c
∞ X
1
a i
= d · nc ·
∈ O(nc ).
t(n) ≤ d · n ·
c
b
1 − bac
c
i =0
Außerdem gilt t(n) ∈ Ω(nc ). Hieraus folgt t(n) ∈ Θ(nc ).
2. Fall: a = b c
t(n) = (k + 1) · d · nc ∈ Θ(nc log n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
14 / 84
Divide & Conquer
Beweis Mastertheorem I
3. Fall a > b c
t(n) =
∈
=
=
=
=
k a k+1
X
−1
a i
c ( bc )
d ·n ·
=
n
·
a
c
b
bc − 1
i =0
a logb (n) Θ nc · c
b
!
nc · alogb (n)
Θ
b c logb (n)
Θ alogb (n)
Θ b logb (a)·logb (n)
Θ nlogb (a)
c
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
15 / 84
Divide & Conquer
Strecken der Eingabe macht nichts
Strecken der Eingabe auf b-Potenz Länge ändert nichts an der Aussage
des Mastertheorems I.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
16 / 84
Divide & Conquer
Strecken der Eingabe macht nichts
Strecken der Eingabe auf b-Potenz Länge ändert nichts an der Aussage
des Mastertheorems I.
Formal: Angenommen die Funktion t erfüllt die Rekursionsgleichung
t(1) = 1
t(n) = a · t(n/b) + d · nc
für b-Potenzen n.
Definiere die Funktion s : N → N durch s(n) = t(m), wobei m die kleinste
b-Potenz größer-gleich n ist ( n ≤ m ≤ bn).
Dann gilt nach dem Mastertheorem I

c
c

falls a < b c
 Θ(m ) = Θ(n )
c
c
Θ(m log m) = Θ(n log n) falls a = b c
s(n) = t(m) ∈
log a
log a

 Θ(m log
b ) = Θ(n log b )
falls a > b c
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
16 / 84
Divide & Conquer
Mastertheorem II
Theorem 3 (Mastertheorem II)
P
Sei r > 0, ri=0 αi < 1 und für eine Konstante c sei
!
r
X
t(⌈αi n⌉) + c · n
t(n) ≤
i =0
Dann gilt t(n) ∈ O(n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
17 / 84
Divide & Conquer
Beweis Mastertheorem II
Wähle ein ε und ein n0 > 0 so, dass αi n0 ≤ n0 − 1 und
r
r
X
X
αi ) · n + r + 1 ≤ (1 − ε)n
⌈αi n⌉ ≤ (
i =0
i =0
für alle n ≥ n0 .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
18 / 84
Divide & Conquer
Beweis Mastertheorem II
Wähle ein ε und ein n0 > 0 so, dass αi n0 ≤ n0 − 1 und
r
r
X
X
αi ) · n + r + 1 ≤ (1 − ε)n
⌈αi n⌉ ≤ (
i =0
i =0
für alle n ≥ n0 .
Wähle ein γ so, dass c < γε und t(n) < γn für alle n < n0 .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
18 / 84
Divide & Conquer
Beweis Mastertheorem II
Wähle ein ε und ein n0 > 0 so, dass αi n0 ≤ n0 − 1 und
r
r
X
X
αi ) · n + r + 1 ≤ (1 − ε)n
⌈αi n⌉ ≤ (
i =0
i =0
für alle n ≥ n0 .
Wähle ein γ so, dass c < γε und t(n) < γn für alle n < n0 .
Für den Induktionsschritt (n ≥ n0 ) gilt:
!
r
X
t(⌈αi n⌉) + cn
t(n) ≤
≤
i =0
r
X
!
γ⌈αi n⌉
i =0
+ cn
(mit Induktion)
≤ (γ(1 − ε) + c)n
≤ γn
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
18 / 84
Divide & Conquer
Mergesort
Wir wollen eine Array A der Länge n sortieren, wobei n = 2k für ein k ≥ 0.
Algorithmus mergesort
procedure mergesort(l , r )
var m : integer;
begin
if (l < r ) then
m := (r + l ) div 2;
mergesort(l , m);
mergesort(m + 1, r );
merge(l , m, r );
endif
endprocedure
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
19 / 84
Divide & Conquer
Mergesort
Algorithmus merge
procedure merge(l , m, r )
var i , j, k : integer;
begin
i = l ; j := m + 1;
for k := 1 to r − l + 1 do
if i = m + 1 or (i ≤ m and j ≤ r and A[j] ≤ A[i ]) then
B[k] := A[j]; j := j + 1
else
B[k] := A[i ]; i := i + 1
endif
endfor
for k := 0 to r − l do
A[l + k] := B[k]
endfor
endprocedure
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
20 / 84
Divide & Conquer
Mergesort
Beachte: merge(l , m, r ) arbeitet in Zeit O(r − l + 1).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
21 / 84
Divide & Conquer
Mergesort
Beachte: merge(l , m, r ) arbeitet in Zeit O(r − l + 1).
Laufzeit: tms (n) = 2 · tms (n/2) + d · n für Konstante d.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
21 / 84
Divide & Conquer
Mergesort
Beachte: merge(l , m, r ) arbeitet in Zeit O(r − l + 1).
Laufzeit: tms (n) = 2 · tms (n/2) + d · n für Konstante d.
Mastertheorem I: tms (n) ∈ O(n log n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
21 / 84
Divide & Conquer
Mergesort
Beachte: merge(l , m, r ) arbeitet in Zeit O(r − l + 1).
Laufzeit: tms (n) = 2 · tms (n/2) + d · n für Konstante d.
Mastertheorem I: tms (n) ∈ O(n log n).
Wir werden noch sehen, dass O(n log n) asymptotisch optimal für
vergleichsbasierte Sortieralgorithmen ist.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
21 / 84
Divide & Conquer
Mergesort
Beachte: merge(l , m, r ) arbeitet in Zeit O(r − l + 1).
Laufzeit: tms (n) = 2 · tms (n/2) + d · n für Konstante d.
Mastertheorem I: tms (n) ∈ O(n log n).
Wir werden noch sehen, dass O(n log n) asymptotisch optimal für
vergleichsbasierte Sortieralgorithmen ist.
Nachteil von Mergesort: kein In-Place-Sortieralgorithmus
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
21 / 84
Divide & Conquer
Mergesort
Beachte: merge(l , m, r ) arbeitet in Zeit O(r − l + 1).
Laufzeit: tms (n) = 2 · tms (n/2) + d · n für Konstante d.
Mastertheorem I: tms (n) ∈ O(n log n).
Wir werden noch sehen, dass O(n log n) asymptotisch optimal für
vergleichsbasierte Sortieralgorithmen ist.
Nachteil von Mergesort: kein In-Place-Sortieralgorithmus
Ein Sortieralgorithmus arbeitet In-Place, falls zu jedem Zeitpunkt nur eine
konstante Zahl von Elementen des Eingabearrays A außerhalb von A
gespeichert wird.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
21 / 84
Divide & Conquer
Mergesort
Beachte: merge(l , m, r ) arbeitet in Zeit O(r − l + 1).
Laufzeit: tms (n) = 2 · tms (n/2) + d · n für Konstante d.
Mastertheorem I: tms (n) ∈ O(n log n).
Wir werden noch sehen, dass O(n log n) asymptotisch optimal für
vergleichsbasierte Sortieralgorithmen ist.
Nachteil von Mergesort: kein In-Place-Sortieralgorithmus
Ein Sortieralgorithmus arbeitet In-Place, falls zu jedem Zeitpunkt nur eine
konstante Zahl von Elementen des Eingabearrays A außerhalb von A
gespeichert wird.
Wir werden noch In-Place-Sortieralgorithmen mit einer Laufzeit von
O(n log n) kennenlernen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
21 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2k für
ein k ≥ 0.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
22 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2k für
ein k ≥ 0.
Schulmethode: O(n2 ) Bit-Operationen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
22 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2k für
ein k ≥ 0.
Schulmethode: O(n2 ) Bit-Operationen.
Anderer Ansatz:
r =
A
B
s =
C
D
Dabei sind A (C ) die ersten und B (D) die letzten n/2 Bits von r (s), d.h.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
22 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2k für
ein k ≥ 0.
Schulmethode: O(n2 ) Bit-Operationen.
Anderer Ansatz:
r =
A
B
s =
C
D
Dabei sind A (C ) die ersten und B (D) die letzten n/2 Bits von r (s), d.h.
r = A 2n/2 + B;
s = C 2n/2 + D
Divide & Conquer
Multiplikation ganzer Zahlen
Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2k für
ein k ≥ 0.
Schulmethode: O(n2 ) Bit-Operationen.
Anderer Ansatz:
r =
A
B
s =
C
D
Dabei sind A (C ) die ersten und B (D) die letzten n/2 Bits von r (s), d.h.
r = A 2n/2 + B;
s = C 2n/2 + D
r s = A C 2n + (A D + B C ) 2n/2 + B D
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
22 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2k für
ein k ≥ 0.
Schulmethode: O(n2 ) Bit-Operationen.
Anderer Ansatz:
r =
A
B
s =
C
D
Dabei sind A (C ) die ersten und B (D) die letzten n/2 Bits von r (s), d.h.
r = A 2n/2 + B;
s = C 2n/2 + D
r s = A C 2n + (A D + B C ) 2n/2 + B D
Mastertheorem I: tmult-ng (n) = 4 · tmult-ng (n/2) + O(n) ∈ O(n2 )
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
22 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Wir wollen zwei natürliche n-bit Zahlen multiplizieren, wobei n = 2k für
ein k ≥ 0.
Schulmethode: O(n2 ) Bit-Operationen.
Anderer Ansatz:
r =
A
B
s =
C
D
Dabei sind A (C ) die ersten und B (D) die letzten n/2 Bits von r (s), d.h.
r = A 2n/2 + B;
s = C 2n/2 + D
r s = A C 2n + (A D + B C ) 2n/2 + B D
Mastertheorem I: tmult-ng (n) = 4 · tmult-ng (n/2) + O(n) ∈ O(n2 )
Nichts gewonnen!
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
22 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Berechne stattdessen besser rekursiv AC , (A − B)(D − C ) und BD.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
23 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Berechne stattdessen besser rekursiv AC , (A − B)(D − C ) und BD.
Aufwand: 3 · tmult (n/2) + O(n)
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
23 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Berechne stattdessen besser rekursiv AC , (A − B)(D − C ) und BD.
Aufwand: 3 · tmult (n/2) + O(n)
Damit:
rs = A C 2n + (A − B) (D − C ) 2n/2 + (B D + A C ) 2n/2 + B D
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
23 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Berechne stattdessen besser rekursiv AC , (A − B)(D − C ) und BD.
Aufwand: 3 · tmult (n/2) + O(n)
Damit:
rs = A C 2n + (A − B) (D − C ) 2n/2 + (B D + A C ) 2n/2 + B D
Gesamtaufwand nach dem Mastertheorem I:
log 3
tmult (n) = 3 · tmult (n/2) + O(n) ∈ O(n log 2 ) = O(n1.58496... ).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
23 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Berechne stattdessen besser rekursiv AC , (A − B)(D − C ) und BD.
Aufwand: 3 · tmult (n/2) + O(n)
Damit:
rs = A C 2n + (A − B) (D − C ) 2n/2 + (B D + A C ) 2n/2 + B D
Gesamtaufwand nach dem Mastertheorem I:
log 3
tmult (n) = 3 · tmult (n/2) + O(n) ∈ O(n log 2 ) = O(n1.58496... ).
Wir haben also durch den Divide & Conquer Ansatz den Exponenten des
naiven Ansatzes von 2 auf 1.58496... heruntergesetzt.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
23 / 84
Divide & Conquer
Multiplikation ganzer Zahlen
Berechne stattdessen besser rekursiv AC , (A − B)(D − C ) und BD.
Aufwand: 3 · tmult (n/2) + O(n)
Damit:
rs = A C 2n + (A − B) (D − C ) 2n/2 + (B D + A C ) 2n/2 + B D
Gesamtaufwand nach dem Mastertheorem I:
log 3
tmult (n) = 3 · tmult (n/2) + O(n) ∈ O(n log 2 ) = O(n1.58496... ).
Wir haben also durch den Divide & Conquer Ansatz den Exponenten des
naiven Ansatzes von 2 auf 1.58496... heruntergesetzt.
Bemerkung: Nach einem Verfahren von Schönhage-Strassen (diskrete
FFT in geeigneten Restklassenringen) lassen sich zwei Binärzahlen der
Länge n in der Zeit O(n log n log log n) multiplizieren.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
23 / 84
Divide & Conquer
Matrixmultiplikation mittels naiven Divide & Conquer
Seien A = (ai ,j )1≤i ,j≤n und B = (bi ,j )1≤i ,j≤n zwei (n × n)-Matrizen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
24 / 84
Divide & Conquer
Matrixmultiplikation mittels naiven Divide & Conquer
Seien A = (ai ,j )1≤i ,j≤n und B = (bi ,j )1≤i ,j≤n zwei (n × n)-Matrizen.
Für die Produktmatrix AB = (ci ,j )1≤i ,j≤n = C gilt
ci ,j =
n
X
ai ,k bk,j
k=1
O(n3 ) skalare Multiplikationen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
24 / 84
Divide & Conquer
Matrixmultiplikation mittels naiven Divide & Conquer
Seien A = (ai ,j )1≤i ,j≤n und B = (bi ,j )1≤i ,j≤n zwei (n × n)-Matrizen.
Für die Produktmatrix AB = (ci ,j )1≤i ,j≤n = C gilt
ci ,j =
n
X
ai ,k bk,j
k=1
O(n3 ) skalare Multiplikationen.
Divide & Conquer: A, B werden in 4 etwa gleichgroße Untermatrizen
unterteilt, wobei sich das Produkt AB = C wie folgt darstellen lässt:
A11
A12
B11
B12
C11
C12
=
A21
A22
B21
B22
C21
C22
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
24 / 84
Divide & Conquer
Matrixmultiplikation naiver Divide-and-Conquer
A11
A21
A12
A22
Markus Lohrey (Universität Siegen)
B11
B21
B12
B22
Algorithmen
=
C11
C21
C12
C22
WS 2013/2014
25 / 84
Divide & Conquer
Matrixmultiplikation naiver Divide-and-Conquer
A11
A21
A12
A22
B11
B21
B12
B22
=
C11
C21
C12
C22
Dabei ergeben sich folgende Beziehungen:
C11 = A11 B11 + A12 B21
C12 = A11 B12 + A12 B22
C21 = A21 B11 + A22 B21
C22 = A21 B12 + A22 B22
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
25 / 84
Divide & Conquer
Matrixmultiplikation naiver Divide-and-Conquer
A11
A21
A12
A22
B11
B21
B12
B22
=
C11
C21
C12
C22
Dabei ergeben sich folgende Beziehungen:
C11 = A11 B11 + A12 B21
C12 = A11 B12 + A12 B22
C21 = A21 B11 + A22 B21
C22 = A21 B12 + A22 B22
Also:
t(n) ∈ 8 · t(n/2) + Θ(n2 ) ∈ Θ(n3 )
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
25 / 84
Divide & Conquer
Matrixmultiplikation naiver Divide-and-Conquer
A11
A21
A12
A22
B11
B21
B12
B22
=
C11
C21
C12
C22
Dabei ergeben sich folgende Beziehungen:
C11 = A11 B11 + A12 B21
C12 = A11 B12 + A12 B22
C21 = A21 B11 + A22 B21
C22 = A21 B12 + A22 B22
Also:
t(n) ∈ 8 · t(n/2) + Θ(n2 ) ∈ Θ(n3 )
Erneut keine Verbesserung.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
25 / 84
Divide & Conquer
Matrixmultiplikation nach Volker Strassen (1969)
Berechne das Produkt von 2 × 2 Matrizen mit 7 Multiplikationen:
M1
:=
(A12 − A22 )(B21 + B22 )
C11
=
M1 + M2 − M4 + M6
M2
:=
(A11 + A22 )(B11 + B22 )
C12
=
M4 + M5
M3
:=
(A11 − A21 )(B11 + B12 )
C21
=
M6 + M7
M4
:=
(A11 + A12 )B22
C22
=
M2 − M3 + M5 − M7
M5
:=
A11 (B12 − B22 )
M6
:=
A22 (B21 − B11 )
M7
:=
(A21 + A22 )B11
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
26 / 84
Divide & Conquer
Matrixmultiplikation nach Volker Strassen (1969)
Berechne das Produkt von 2 × 2 Matrizen mit 7 Multiplikationen:
M1
:=
(A12 − A22 )(B21 + B22 )
C11
=
M1 + M2 − M4 + M6
M2
:=
(A11 + A22 )(B11 + B22 )
C12
=
M4 + M5
M3
:=
(A11 − A21 )(B11 + B12 )
C21
=
M6 + M7
M4
:=
(A11 + A12 )B22
C22
=
M2 − M3 + M5 − M7
M5
:=
A11 (B12 − B22 )
M6
:=
A22 (B21 − B11 )
M7
:=
(A21 + A22 )B11
Laufzeit: t(n) ∈ 7 · t(n/2) + Θ(n2 ).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
26 / 84
Divide & Conquer
Matrixmultiplikation nach Volker Strassen (1969)
Berechne das Produkt von 2 × 2 Matrizen mit 7 Multiplikationen:
M1
:=
(A12 − A22 )(B21 + B22 )
C11
=
M1 + M2 − M4 + M6
M2
:=
(A11 + A22 )(B11 + B22 )
C12
=
M4 + M5
M3
:=
(A11 − A21 )(B11 + B12 )
C21
=
M6 + M7
M4
:=
(A11 + A12 )B22
C22
=
M2 − M3 + M5 − M7
M5
:=
A11 (B12 − B22 )
M6
:=
A22 (B21 − B11 )
M7
:=
(A21 + A22 )B11
Laufzeit: t(n) ∈ 7 · t(n/2) + Θ(n2 ).
Mastertheorem I (a = 7, b = 2, c = 2):
t(n) ∈ Θ(nlog2 7 ) = Θ(n2,81... )
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
26 / 84
Divide & Conquer
Die Geschichte nach Strassen
Strassens Resultat wurde über die Jahre stetig verbessert:
Strassen 1969: n2,81...
Pan 1979: n2,796...
Bini, Capovani, Romani, Lotti 1979: n2,78...
Schönhage 1981: n2,522...
Romani 1982: n2,517...
Coppersmith, Winograd 1981: n2.496...
Strassen 1986: n2,479...
Coppersmith, Winograd 1987: n2.376...
Stothers 2010: n2,374...
Williams 2011: n2,3727...
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
27 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Betrachte zwei Polynome (mit Koeffizienten etwa aus C):
f (x) = a0 + a1 x + a2 x 2 + · · · an x n , g (x) = b0 + b1 x + b2 x 2 + · · · bm x m
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
28 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Betrachte zwei Polynome (mit Koeffizienten etwa aus C):
f (x) = a0 + a1 x + a2 x 2 + · · · an x n , g (x) = b0 + b1 x + b2 x 2 + · · · bm x m
repräsentiert durch ihre Koeffizientenfolgen
f = (a0 , . . . , an , an+1 , . . . , aN−1 ), g = (b0 , . . . , bm , bm+1 , . . . , bN−1 )
wobei N = n + m + 1, an+1 = · · · = aN−1 = bb+1 = · · · = bN−1 = 0.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
28 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Betrachte zwei Polynome (mit Koeffizienten etwa aus C):
f (x) = a0 + a1 x + a2 x 2 + · · · an x n , g (x) = b0 + b1 x + b2 x 2 + · · · bm x m
repräsentiert durch ihre Koeffizientenfolgen
f = (a0 , . . . , an , an+1 , . . . , aN−1 ), g = (b0 , . . . , bm , bm+1 , . . . , bN−1 )
wobei N = n + m + 1, an+1 = · · · = aN−1 = bb+1 = · · · = bN−1 = 0.
Wir wollen das Produktpolynom
(fg )(x) = a0 b0 + (a1 b0 + a0 b1 )x + · · · + (a0 bN−1 + · · · + aN−1 b0 )x N−1
berechnen, welches durch die Koeffizientenfolge
fg = (a0 b0 , a1 b0 + a0 b1 , . . . , a0 bN−1 + · · · + aN−1 b0 ),
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
28 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Betrachte zwei Polynome (mit Koeffizienten etwa aus C):
f (x) = a0 + a1 x + a2 x 2 + · · · an x n , g (x) = b0 + b1 x + b2 x 2 + · · · bm x m
repräsentiert durch ihre Koeffizientenfolgen
f = (a0 , . . . , an , an+1 , . . . , aN−1 ), g = (b0 , . . . , bm , bm+1 , . . . , bN−1 )
wobei N = n + m + 1, an+1 = · · · = aN−1 = bb+1 = · · · = bN−1 = 0.
Wir wollen das Produktpolynom
(fg )(x) = a0 b0 + (a1 b0 + a0 b1 )x + · · · + (a0 bN−1 + · · · + aN−1 b0 )x N−1
berechnen, welches durch die Koeffizientenfolge
fg = (a0 b0 , a1 b0 + a0 b1 , . . . , a0 bN−1 + · · · + aN−1 b0 ),
(die Konvolution der Folgen f und g ) repräsentiert wird.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
28 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Naive Berechnung von fg : Zeit O(N 2 )
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
29 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Naive Berechnung von fg : Zeit O(N 2 )
FFT reduziert die Zeit auf O(N log(N))
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
29 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Naive Berechnung von fg : Zeit O(N 2 )
FFT reduziert die Zeit auf O(N log(N))
Grundidee: Punktrepräsentation von Polynomen
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
29 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Naive Berechnung von fg : Zeit O(N 2 )
FFT reduziert die Zeit auf O(N log(N))
Grundidee: Punktrepräsentation von Polynomen
Ein Polynom f vom Grad N − 1 kann eindeutig durch die Folge der Werte
(f (ζ0 ), f (ζ1 ), . . . , f (ζN−1 ))
repräsentiert werden, wobei ζ0 , . . . , ζN−1 N verschiedene Werte aus dem
Grundbereich (z.B. komplexe Zahlen), sind.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
29 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Naive Berechnung von fg : Zeit O(N 2 )
FFT reduziert die Zeit auf O(N log(N))
Grundidee: Punktrepräsentation von Polynomen
Ein Polynom f vom Grad N − 1 kann eindeutig durch die Folge der Werte
(f (ζ0 ), f (ζ1 ), . . . , f (ζN−1 ))
repräsentiert werden, wobei ζ0 , . . . , ζN−1 N verschiedene Werte aus dem
Grundbereich (z.B. komplexe Zahlen), sind.
Offensichtlich gilt (fg )(ζ) = f (ζ)g (ζ)
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
29 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Naive Berechnung von fg : Zeit O(N 2 )
FFT reduziert die Zeit auf O(N log(N))
Grundidee: Punktrepräsentation von Polynomen
Ein Polynom f vom Grad N − 1 kann eindeutig durch die Folge der Werte
(f (ζ0 ), f (ζ1 ), . . . , f (ζN−1 ))
repräsentiert werden, wobei ζ0 , . . . , ζN−1 N verschiedene Werte aus dem
Grundbereich (z.B. komplexe Zahlen), sind.
Offensichtlich gilt (fg )(ζ) = f (ζ)g (ζ)
Die Punktrepräsentation der Konvolution von f und g kann in Zeit O(N)
aus den Punktrepräsentationen von f und g berechnet werden.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
29 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
30 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
Auswertung
Punktrepr. f und g
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
30 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
Auswertung
Punktrepr. f und g
Markus Lohrey (Universität Siegen)
punktweises ×
Algorithmen
Punktrepr. fg
WS 2013/2014
30 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
Koeffizientenrepr. von fg
Auswertung
Punktrepr. f und g
Markus Lohrey (Universität Siegen)
interpolation
punktweises ×
Algorithmen
Punktrepr. fg
WS 2013/2014
30 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Der entscheidende Punkt ist die Auswahl der Punkte ζ0 , ζ1 , . . . , ζN−1 .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
31 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Der entscheidende Punkt ist die Auswahl der Punkte ζ0 , ζ1 , . . . , ζN−1 .
Annahme: Die Koeffizienten der Polynome stammen aus einem Körper F,
so dass gilt:
N hat ein multiplikatives Inverses in F, d.h. die Charakteristik von F
teilt nicht N.
Das Polynom X N − 1 hat N verschiedene Nullstellen – die N-ten
Einheitswurzeln – welche sich als ω i (0 ≤ i < N) für eine Nullstelle ω
schreiben lassen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
31 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Der entscheidende Punkt ist die Auswahl der Punkte ζ0 , ζ1 , . . . , ζN−1 .
Annahme: Die Koeffizienten der Polynome stammen aus einem Körper F,
so dass gilt:
N hat ein multiplikatives Inverses in F, d.h. die Charakteristik von F
teilt nicht N.
Das Polynom X N − 1 hat N verschiedene Nullstellen – die N-ten
Einheitswurzeln – welche sich als ω i (0 ≤ i < N) für eine Nullstelle ω
schreiben lassen.
Für F = C sind die N-ten Einheitswurzeln etwa von der Form ω j
2πi
(0 ≤ j < N), wobei ω = e N .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
31 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Der entscheidende Punkt ist die Auswahl der Punkte ζ0 , ζ1 , . . . , ζN−1 .
Annahme: Die Koeffizienten der Polynome stammen aus einem Körper F,
so dass gilt:
N hat ein multiplikatives Inverses in F, d.h. die Charakteristik von F
teilt nicht N.
Das Polynom X N − 1 hat N verschiedene Nullstellen – die N-ten
Einheitswurzeln – welche sich als ω i (0 ≤ i < N) für eine Nullstelle ω
schreiben lassen.
Für F = C sind die N-ten Einheitswurzeln etwa von der Form ω j
2πi
(0 ≤ j < N), wobei ω = e N .
Die Nullstelle ω wird auch als primitive N-te Einheitswurzel bezeichnet.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
31 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Einige nützliche Fakten aus der Algebra:
Sei ω eine primitive N-te Einheitswurzel.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
32 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Einige nützliche Fakten aus der Algebra:
Sei ω eine primitive N-te Einheitswurzel.
Für alle i , j ∈ Z gilt: ω i = ω j g.d.w. i ≡ j mod N.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
32 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Einige nützliche Fakten aus der Algebra:
Sei ω eine primitive N-te Einheitswurzel.
Für alle i , j ∈ Z gilt: ω i = ω j g.d.w. i ≡ j mod N.
Für i ∈ Z ist ω i eine primitive N-te Einheitswurzel g.d.w.
ggT(i , N) = 1 (wobei ggT(i , N) der größte gemeinsame Teiler von i
und N ist).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
32 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Einige nützliche Fakten aus der Algebra:
Sei ω eine primitive N-te Einheitswurzel.
Für alle i , j ∈ Z gilt: ω i = ω j g.d.w. i ≡ j mod N.
Für i ∈ Z ist ω i eine primitive N-te Einheitswurzel g.d.w.
ggT(i , N) = 1 (wobei ggT(i , N) der größte gemeinsame Teiler von i
und N ist).
Insbesondere ist ω −1 = ω N−1 eine primitive N-te Einheitswurzel.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
32 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Fixiere eine primitive N-te Einheitswurzel ω.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
33 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Fixiere eine primitive N-te Einheitswurzel ω.
Wir wählen die Punkte ζi = ω i (0 ≤ i ≤ N − 1) für die Auswertung von f
und g .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
33 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Fixiere eine primitive N-te Einheitswurzel ω.
Wir wählen die Punkte ζi = ω i (0 ≤ i ≤ N − 1) für die Auswertung von f
und g .
Auswertung von f = a0 + a1 x + · · · aN−1 x N−1 an den Punkten
ω 0 = 1, ω 1 , . . . , ω N−1 läuft auf eine Matrixmultiplikation hinaus:


 
1
1
1
···
1
a0
f (1)
1
2
N−1  
1


ω
ω
·
·
·
ω
a
f

  1   (ω)
2
4
2(N−1)  
2
1
 
ω
ω
·
·
·
ω

  a2  =  f (ω )
 ..
  ..  
..
..
..
..
.
 .  
.
.
.
.
1 ω N−1 ω 2(N−1) · · ·
Markus Lohrey (Universität Siegen)
2
ω (N−1)
Algorithmen
aN−1







N−1
f (ω
)
WS 2013/2014
33 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Fixiere eine primitive N-te Einheitswurzel ω.
Wir wählen die Punkte ζi = ω i (0 ≤ i ≤ N − 1) für die Auswertung von f
und g .
Auswertung von f = a0 + a1 x + · · · aN−1 x N−1 an den Punkten
ω 0 = 1, ω 1 , . . . , ω N−1 läuft auf eine Matrixmultiplikation hinaus:


 
1
1
1
···
1
a0
f (1)
1
2
N−1  
1


ω
ω
·
·
·
ω
a
f

  1   (ω)
2
4
2(N−1)  
2
1
 
ω
ω
·
·
·
ω

  a2  =  f (ω )
 ..
  ..  
..
..
..
..
.
 .  
.
.
.
.
1 ω N−1 ω 2(N−1) · · ·
2
ω (N−1)
aN−1







N−1
f (ω
)
Die durch die Matrix FN (ω) = (ω ij )0≤i ,j<N realisierte lineare Abbildung
wird als diskrete Fourier Transformation bezeichnet.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
33 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Lemma 4
−1 =
(F
N−ij(ω))
ω
N
0≤i ,j<N
1
−1
N FN (ω ),
d.h. das Inverse der Matrix (ω ij )0≤i ,j<N ist
(beachte: ω −1 ist eine primitive N-te Einheitswurzel).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
34 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Lemma 4
−1 =
(F
N−ij(ω))
ω
N
0≤i ,j<N
1
−1
N FN (ω ),
d.h. das Inverse der Matrix (ω ij )0≤i ,j<N ist
(beachte: ω −1 ist eine primitive N-te Einheitswurzel).
Beweis: Da x N − 1 = (x − 1) ·
PN−1 j
eine Nullstelle von j=0
x .
Markus Lohrey (Universität Siegen)
PN−1
j=0
x j gilt, ist jedes ω i für 0 < i < N
Algorithmen
WS 2013/2014
34 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Lemma 4
−1 =
(F
N−ij(ω))
ω
N
0≤i ,j<N
1
−1
N FN (ω ),
d.h. das Inverse der Matrix (ω ij )0≤i ,j<N ist
(beachte: ω −1 ist eine primitive N-te Einheitswurzel).
Beweis: Da x N − 1 = (x − 1) ·
PN−1 j
eine Nullstelle von j=0
x .
PN−1
j=0
x j gilt, ist jedes ω i für 0 < i < N
Daher gilt für alle 0 ≤ i < N:
(
N−1
X
0
falls i > 0
i ·j
ω =
N
falls i = 0
j=0
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
34 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Lemma 4
−1 =
(F
N−ij(ω))
ω
N
0≤i ,j<N
1
−1
N FN (ω ),
d.h. das Inverse der Matrix (ω ij )0≤i ,j<N ist
(beachte: ω −1 ist eine primitive N-te Einheitswurzel).
Beweis: Da x N − 1 = (x − 1) ·
PN−1 j
eine Nullstelle von j=0
x .
PN−1
j=0
x j gilt, ist jedes ω i für 0 < i < N
Daher gilt für alle 0 ≤ i < N:
(
N−1
X
0
falls i > 0
i ·j
ω =
N
falls i = 0
j=0
Wir erhalten für alle 0 ≤ i , j < N:
N−1
X
k=0
ω ik ω −kj =
N−1
X
k=0
Markus Lohrey (Universität Siegen)
ω k(i −j)
(
0
=
N
Algorithmen
falls i 6= j
falls i = j
WS 2013/2014
34 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir müssen nun noch die diskrete Fouriertransformation
f 7→ FN (ω)f
(wobei f = (a0 , a1 , . . . , aN−1 )T ) in Zeit O(N log(N)) berechnen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
35 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir müssen nun noch die diskrete Fouriertransformation
f 7→ FN (ω)f
(wobei f = (a0 , a1 , . . . , aN−1 )T ) in Zeit O(N log(N)) berechnen.
Dann kann die inverse diskrete Fouriertransformation (= Interpolation)
h 7→ (FN (ω))−1 h =
1
FN (ω −1 )h
N
in der gleichen Zeitschranke berechnet werden.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
35 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir müssen nun noch die diskrete Fouriertransformation
f 7→ FN (ω)f
(wobei f = (a0 , a1 , . . . , aN−1 )T ) in Zeit O(N log(N)) berechnen.
Dann kann die inverse diskrete Fouriertransformation (= Interpolation)
h 7→ (FN (ω))−1 h =
1
FN (ω −1 )h
N
in der gleichen Zeitschranke berechnet werden.
Die “Schulmethode” für die Multiplikation einer Matrix mit einem Vektor
benötigt Zeit O(N 2 ): kein Gewinn gegenüber der “Schulmethode” für
Polynommultiplikation.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
35 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir müssen nun noch die diskrete Fouriertransformation
f 7→ FN (ω)f
(wobei f = (a0 , a1 , . . . , aN−1 )T ) in Zeit O(N log(N)) berechnen.
Dann kann die inverse diskrete Fouriertransformation (= Interpolation)
h 7→ (FN (ω))−1 h =
1
FN (ω −1 )h
N
in der gleichen Zeitschranke berechnet werden.
Die “Schulmethode” für die Multiplikation einer Matrix mit einem Vektor
benötigt Zeit O(N 2 ): kein Gewinn gegenüber der “Schulmethode” für
Polynommultiplikation.
Wir berechnen FN (ω)f = (ω ij )0≤i ,j<N f mittel Divide & Conquer.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
35 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Angenommen N ist gerade. Für f (x) = a0 + a1 x + · · · + aN−1 x N−1 sei
f0 (x) = a0 + a2 x 2 + a4 x 4 + · · · + aN−2 x N−2
N−2
b
f0 (x) = a0 + a2 x + a4 x 2 + · · · + aN−2 x 2
f1 (x) = a1 + a3 x 2 + a5 x 4 + · · · + aN−1 x N−2
N−2
b
f1 (x) = a1 + a3 x + a5 x 2 + · · · + aN−1 x 2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
36 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Angenommen N ist gerade. Für f (x) = a0 + a1 x + · · · + aN−1 x N−1 sei
f0 (x) = a0 + a2 x 2 + a4 x 4 + · · · + aN−2 x N−2
N−2
b
f0 (x) = a0 + a2 x + a4 x 2 + · · · + aN−2 x 2
f1 (x) = a1 + a3 x 2 + a5 x 4 + · · · + aN−1 x N−2
N−2
b
f1 (x) = a1 + a3 x + a5 x 2 + · · · + aN−1 x 2
Also: f (x) = f0 (x) + xf1 (x), f0 (x) = b
f0 (x 2 ) und f1 (x) = b
f1 (x 2 ).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
36 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Angenommen N ist gerade. Für f (x) = a0 + a1 x + · · · + aN−1 x N−1 sei
f0 (x) = a0 + a2 x 2 + a4 x 4 + · · · + aN−2 x N−2
N−2
b
f0 (x) = a0 + a2 x + a4 x 2 + · · · + aN−2 x 2
f1 (x) = a1 + a3 x 2 + a5 x 4 + · · · + aN−1 x N−2
N−2
b
f1 (x) = a1 + a3 x + a5 x 2 + · · · + aN−1 x 2
Also: f (x) = f0 (x) + xf1 (x), f0 (x) = b
f0 (x 2 ) und f1 (x) = b
f1 (x 2 ).
Die Polynome b
f0 (x) und b
f1 (x) haben Grad ≤ N−2 .
2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
36 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Angenommen N ist gerade. Für f (x) = a0 + a1 x + · · · + aN−1 x N−1 sei
f0 (x) = a0 + a2 x 2 + a4 x 4 + · · · + aN−2 x N−2
N−2
b
f0 (x) = a0 + a2 x + a4 x 2 + · · · + aN−2 x 2
f1 (x) = a1 + a3 x 2 + a5 x 4 + · · · + aN−1 x N−2
N−2
b
f1 (x) = a1 + a3 x + a5 x 2 + · · · + aN−1 x 2
Also: f (x) = f0 (x) + xf1 (x), f0 (x) = b
f0 (x 2 ) und f1 (x) = b
f1 (x 2 ).
Die Polynome b
f0 (x) und b
f1 (x) haben Grad ≤ N−2 .
Sei 0 ≤ i < N. Da
ω2
eine primitive
2
N
2 -Einheitswurzel
(FN (ω)f0 )i = f0 (ω i ) = b
f0 (ω 2i ) = b
f0 (ω 2i mod N ) =
ist, gilt:
N
N
b
f0 (ω 2(i mod 2 ) ) = b
f0 )i mod N ,
f0 ((ω 2 )i mod 2 ) = (F N (ω 2 )b
Markus Lohrey (Universität Siegen)
Algorithmen
2
2
WS 2013/2014
36 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir erhalten
FN (ω)f0 =
F N (ω 2 )b
f0
2
2
F N (ω )b
f0
2
und analog
FN (ω)f1 =
!
!
F N (ω 2 )b
f1
2
.
F N (ω 2 )b
f1
2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
37 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir erhalten
FN (ω)f0 =
F N (ω 2 )b
f0
2
2
F N (ω )b
f0
2
und analog
FN (ω)f1 =
!
!
F N (ω 2 )b
f1
2
.
F N (ω 2 )b
f1
2
Mit f (x) = f0 (x) + xf1 (x) folgt
FN (ω)f = FN (ω)f0 + (FN (ω)x ◦ FN (ω)f1 ),
wobei FN (ω)x = (1, ω, ω 2 , . . . , ω N−1 )T und “◦” die punktweise
Multiplikation von Vektoren bezeichnet.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
37 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir haben somit die Berechnung von FN (ω)f reduziert auf:
Die Berechnung von F N (ω 2 )b
f0 und F N (ω 2 )b
f1
2
2
(2 FFTs der Dimension N/2)
O(n) viele weitere arithmetische Operationen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
38 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir haben somit die Berechnung von FN (ω)f reduziert auf:
Die Berechnung von F N (ω 2 )b
f0 und F N (ω 2 )b
f1
2
2
(2 FFTs der Dimension N/2)
O(n) viele weitere arithmetische Operationen.
Wir erhalten somit die Rekursionsgleichung
Tfft (N) = 2Tfft (N/2) + dN
für eine Konstante d.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
38 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Wir haben somit die Berechnung von FN (ω)f reduziert auf:
Die Berechnung von F N (ω 2 )b
f0 und F N (ω 2 )b
f1
2
2
(2 FFTs der Dimension N/2)
O(n) viele weitere arithmetische Operationen.
Wir erhalten somit die Rekursionsgleichung
Tfft (N) = 2Tfft (N/2) + dN
für eine Konstante d.
Mastertheorem I (a = b = 2, c = 1):
Tfft (N) ∈ θ(N log N).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
38 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
39 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
FN (ω)
O(N log(N)) Auswertung
Punktrepr. f und g
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
39 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
FN (ω)
O(N log(N)) Auswertung
Punktrepr. f und g
Markus Lohrey (Universität Siegen)
punktweises ×
O(N)
Algorithmen
Punktrepr. fg
WS 2013/2014
39 / 84
Divide & Conquer
Schnelle Fourier Transformation (FFT)
Grundprinzip der FFT:
Koeffizientenrepr. von f und g
Koeffizientenrepr. von fg
FN (ω)
O(N log(N)) Auswertung
Punktrepr. f und g
Markus Lohrey (Universität Siegen)
Interpolation O(N log(N))
1
−1
N FN (ω )
punktweises ×
O(N)
Algorithmen
Punktrepr. fg
WS 2013/2014
39 / 84
Sortieren
Überblick
Untere Schranke für vergleichsbasierte Sortieralgorithmen
Heapsort
Quicksort
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
40 / 84
Sortieren
Untere Schranke für vergleichsbasierte Sortieralgorithmen
Ein Sortieralgorithmus ist vergleichsbasiert falls die Elemente des Arrays
einen Datentypen bilden, dessen einzige Operation der Vergleich zweier
Elemente ist.
Theorem 5
Jeder vergleichsbasierte Sortieralgorithmus benötigt Ω(n log n) Vergleiche
zum Sortieren eines Arrays der Länge n.
Beweis: Wir führen den Algorithmus in Gedanken auf einem Array
a[1, . . . , n] aus, ohne dabei die konkreten Werte a[i ] zu kennen.
Dies ergibt einen Entscheidungsbaum, der wie folgt konstruiert ist.
Angenommen, der Algorithmus vergleicht als erstes a[i ] und a[j].
Wir beschriften die Wurzel des Entscheidungsbaums mit i : j.
Der linke (bzw. rechte) Teilbaum ergibt sich, indem wir a[i ] < a[j] (bzw.
a[i ] > a[j]) annehmen, und den Algorithmus unter dieser Annahme weiter
laufen lassen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
41 / 84
Sortieren
Untere Schranke für vergleichsbasierte Sortieralgorithmen
Beispiel:
2:3
1:2
1, 2, 3
1:3
1 : 3 1, 3, 2
2, 1, 3
2, 3, 1
1:2
3, 1, 2
3, 2, 1
Beachte: Die Tiefe (= max. Anzahl der Kanten von der Wurzel zu einem
Blatt) des Entscheidunbsbaums ist die maximale Anzahl von Vergleichen
des Algorithmus auf einem Array der Länge n.
Ein Binärbaum mit n! vielen Blättern hat Tiefe mindestens log2 (n!).
√
Stirlings Formel (n! > 2πn(n/e)n ) impliziert
log2 (n!) ≥ n log2 (n) − log2 (e)n + Ω(log n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
42 / 84
Sortieren
Heaps
Definition 6
Ein (Max-)Heap ist ein Feld a[1 . . . n] mit der Eigenschaft a[⌊i /2⌋] ≥ a[i ]
für alle 2 ≤ i ≤ ⌊n⌋.
Beispiel:
1
2
3
16 14 10
Markus Lohrey (Universität Siegen)
4
5
6
7
8
9
10
8
7
9
3
2
4
1
Algorithmen
WS 2013/2014
43 / 84
Sortieren
Heaps
Definition 6
Ein (Max-)Heap ist ein Feld a[1 . . . n] mit der Eigenschaft a[⌊i /2⌋] ≥ a[i ]
für alle 2 ≤ i ≤ ⌊n⌋.
Beispiel:
1
2
3
16 14 10
4
5
6
7
8
9
10
8
7
9
3
2
4
1
1
16
Markus Lohrey (Universität Siegen)
2
3
14
10
4
5
6
7
8
7
9
3
8
9
2
4 1
10
Algorithmen
WS 2013/2014
43 / 84
Sortieren
Einsinkprozess
Als erstes wollen wir die Einträge eines Arrays a[1, . . . , n] so permutieren,
dass danach die Heap-Bedingung erfüllt ist.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
44 / 84
Sortieren
Einsinkprozess
Als erstes wollen wir die Einträge eines Arrays a[1, . . . , n] so permutieren,
dass danach die Heap-Bedingung erfüllt ist.
Angenommen, das Subarray a[i + 1, . . . , n] erfüllt bereits die
Heap-Bedingung.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
44 / 84
Sortieren
Einsinkprozess
Als erstes wollen wir die Einträge eines Arrays a[1, . . . , n] so permutieren,
dass danach die Heap-Bedingung erfüllt ist.
Angenommen, das Subarray a[i + 1, . . . , n] erfüllt bereits die
Heap-Bedingung.
Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i ] einsinken:
i
x
Markus Lohrey (Universität Siegen)
2i
2i + 1
y
z
Algorithmen
WS 2013/2014
44 / 84
Sortieren
Einsinkprozess
Als erstes wollen wir die Einträge eines Arrays a[1, . . . , n] so permutieren,
dass danach die Heap-Bedingung erfüllt ist.
Angenommen, das Subarray a[i + 1, . . . , n] erfüllt bereits die
Heap-Bedingung.
Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i ] einsinken:
i
x
2i
2i + 1
y
z
Mit 2 Vergleichen können wir max{x, y , z} bestimmen.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
44 / 84
Sortieren
Einsinkprozess
Als erstes wollen wir die Einträge eines Arrays a[1, . . . , n] so permutieren,
dass danach die Heap-Bedingung erfüllt ist.
Angenommen, das Subarray a[i + 1, . . . , n] erfüllt bereits die
Heap-Bedingung.
Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i ] einsinken:
i
x
2i
2i + 1
y
z
Mit 2 Vergleichen können wir max{x, y , z} bestimmen.
Ist x das Max., so stoppt der Einsinkprozess.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
44 / 84
Sortieren
Einsinkprozess
Als erstes wollen wir die Einträge eines Arrays a[1, . . . , n] so permutieren,
dass danach die Heap-Bedingung erfüllt ist.
Angenommen, das Subarray a[i + 1, . . . , n] erfüllt bereits die
Heap-Bedingung.
Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i ] einsinken:
i
x
2i
2i + 1
y
z
Mit 2 Vergleichen können wir max{x, y , z} bestimmen.
Ist y das Max., so vertauschen wir x und y und machen bei 2i weiter.
i
y
Markus Lohrey (Universität Siegen)
2i
2i + 1
x
z
Algorithmen
WS 2013/2014
44 / 84
Sortieren
Einsinkprozess
Als erstes wollen wir die Einträge eines Arrays a[1, . . . , n] so permutieren,
dass danach die Heap-Bedingung erfüllt ist.
Angenommen, das Subarray a[i + 1, . . . , n] erfüllt bereits die
Heap-Bedingung.
Um die Heap-Bedingung auch für i zu erzwingen, lassen wir a[i ] einsinken:
i
x
2i
2i + 1
y
z
Mit 2 Vergleichen können wir max{x, y , z} bestimmen.
Ist z das Max., so vertauschen wir x und z und machen bei 2i + 1 weiter.
i
z
Markus Lohrey (Universität Siegen)
2i
2i + 1
y
x
Algorithmen
WS 2013/2014
44 / 84
Sortieren
Reheap
Algorithmus Reheap
procedure reheap(i , n: integer)
var m: integer;
begin
if i ≤ n/2 then
m := max{a[i ], a[2i ], a[2i + 1]};
if (m 6= a[i ]) ∧ (m = a[2i ]) then
swap(i , 2i );
reheap(2i , n)
elsif (m 6= a[i ]) ∧ (m = a[2i + 1]) then
swap(i , 2i + 1);
reheap(2i + 1, n)
endif
endif
endprocedure
Markus Lohrey (Universität Siegen)
Algorithmen
(∗ i ist die Wurzel ∗)
(∗ 2 Vergleiche! ∗)
(∗ vertausche x, y ∗)
(∗ vertausche x, z ∗)
WS 2013/2014
45 / 84
Sortieren
Heap-Aufbau
Algorithmus Build Heap
procedure build-heap(n: integer)
begin
for i := n2 downto 1 do
reheap(i , n)
endfor
endprocedure
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
46 / 84
Sortieren
Heap-Aufbau
Algorithmus Build Heap
procedure build-heap(n: integer)
begin
for i := n2 downto 1 do
reheap(i , n)
endfor
endprocedure
Invariante: Vor dem Aufruf von reheap(i , n) erfüllt das Subarray
a[i + 1, . . . , n] die Heap-Bedingung.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
46 / 84
Sortieren
Heap-Aufbau
Algorithmus Build Heap
procedure build-heap(n: integer)
begin
for i := n2 downto 1 do
reheap(i , n)
endfor
endprocedure
Invariante: Vor dem Aufruf von reheap(i , n) erfüllt das Subarray
a[i + 1, . . . , n] die Heap-Bedingung.
Für i = n2 ist dies trivialerweise richtig.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
46 / 84
Sortieren
Heap-Aufbau
Algorithmus Build Heap
procedure build-heap(n: integer)
begin
for i := n2 downto 1 do
reheap(i , n)
endfor
endprocedure
Invariante: Vor dem Aufruf von reheap(i , n) erfüllt das Subarray
a[i + 1, . . . , n] die Heap-Bedingung.
Für i = n2 ist dies trivialerweise richtig.
Angenommen die Invariante gilt für i .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
46 / 84
Sortieren
Heap-Aufbau
Algorithmus Build Heap
procedure build-heap(n: integer)
begin
for i := n2 downto 1 do
reheap(i , n)
endfor
endprocedure
Invariante: Vor dem Aufruf von reheap(i , n) erfüllt das Subarray
a[i + 1, . . . , n] die Heap-Bedingung.
Für i = n2 ist dies trivialerweise richtig.
Angenommen die Invariante gilt für i .
Die Heap-Bedingung ist daher nur für i eventuell verletzt.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
46 / 84
Sortieren
Heap-Aufbau
Algorithmus Build Heap
procedure build-heap(n: integer)
begin
for i := n2 downto 1 do
reheap(i , n)
endfor
endprocedure
Invariante: Vor dem Aufruf von reheap(i , n) erfüllt das Subarray
a[i + 1, . . . , n] die Heap-Bedingung.
Für i = n2 ist dies trivialerweise richtig.
Angenommen die Invariante gilt für i .
Die Heap-Bedingung ist daher nur für i eventuell verletzt.
Nach dem Einsinken von a[i ] gilt dann die Heap-Bedingung auch für i .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
46 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Theorem 7
Built-heap läuft in Zeit O(n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
47 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Theorem 7
Built-heap läuft in Zeit O(n).
Beweis: Einsinken von a[i ] kostet 2 · (Höhe des Teilbaums unter a[i ]) viele
Vergleiche.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
47 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Theorem 7
Built-heap läuft in Zeit O(n).
Beweis: Einsinken von a[i ] kostet 2 · (Höhe des Teilbaums unter a[i ]) viele
Vergleiche.
Wir führen die Analyse für n = 2k − 1 durch.
Dann haben wir eine vollen Binärbaum der Tiefe k − 1 vorliegen.
Es gibt dann
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
47 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Theorem 7
Built-heap läuft in Zeit O(n).
Beweis: Einsinken von a[i ] kostet 2 · (Höhe des Teilbaums unter a[i ]) viele
Vergleiche.
Wir führen die Analyse für n = 2k − 1 durch.
Dann haben wir eine vollen Binärbaum der Tiefe k − 1 vorliegen.
Es gibt dann
20 Bäume der Höhe k − 1,
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
47 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Theorem 7
Built-heap läuft in Zeit O(n).
Beweis: Einsinken von a[i ] kostet 2 · (Höhe des Teilbaums unter a[i ]) viele
Vergleiche.
Wir führen die Analyse für n = 2k − 1 durch.
Dann haben wir eine vollen Binärbaum der Tiefe k − 1 vorliegen.
Es gibt dann
20 Bäume der Höhe k − 1,
21 Bäume der Höhe k − 2,
..
.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
47 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Theorem 7
Built-heap läuft in Zeit O(n).
Beweis: Einsinken von a[i ] kostet 2 · (Höhe des Teilbaums unter a[i ]) viele
Vergleiche.
Wir führen die Analyse für n = 2k − 1 durch.
Dann haben wir eine vollen Binärbaum der Tiefe k − 1 vorliegen.
Es gibt dann
20 Bäume der Höhe k − 1,
21 Bäume der Höhe k − 2,
..
.
2i Bäume der Höhe k − 1 − i ,
..
.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
47 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Theorem 7
Built-heap läuft in Zeit O(n).
Beweis: Einsinken von a[i ] kostet 2 · (Höhe des Teilbaums unter a[i ]) viele
Vergleiche.
Wir führen die Analyse für n = 2k − 1 durch.
Dann haben wir eine vollen Binärbaum der Tiefe k − 1 vorliegen.
Es gibt dann
20 Bäume der Höhe k − 1,
21 Bäume der Höhe k − 2,
..
.
2i Bäume der Höhe k − 1 − i ,
..
.
2k−1 Bäume der Höhe 0.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
47 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Daher sind zum Heapaufbau maximal
2·
k−1
X
i =0
i
2 (k − 1 − i ) = 2 ·
k−1
X
2k−1−i i
i =0
k−1
X
= 2k ·
i =0
i · 2−i
≤ (n + 1) ·
viele Vergleiche nötig.
P
Behauptung: j≥0 j · 2−j = 2
X
i ≥0
i · 2−i
Beweise der Behauptung: Für |z| < 1 gilt:
X
j≥0
zj =
1
.
1−z
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
48 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Ableiten ergibt
f
X
j≥0
j · z j−1 =
1
,
(1 − z)2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
49 / 84
Sortieren
Zeitanalyse für Heap-Aufbau
Ableiten ergibt
f
X
j≥0
j · z j−1 =
und damit
X
j · zj =
j≥0
1
,
(1 − z)2
z
.
(1 − z)2
Einsetzen von z = 1/2 ergibt
X
j≥0
Markus Lohrey (Universität Siegen)
j · 2−j = 2
Algorithmen
WS 2013/2014
49 / 84
Sortieren
Standard Heapsort
Algorithmus Heapsort
procedure heapsort(n: integer)
begin
build-heap(n)
for i := n downto 2 do
swap(1, i );
reheap(1, i − 1)
endfor
endprocedure
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
50 / 84
Sortieren
Standard Heapsort
Algorithmus Heapsort
procedure heapsort(n: integer)
begin
build-heap(n)
for i := n downto 2 do
swap(1, i );
reheap(1, i − 1)
endfor
endprocedure
Theorem 8
Standard Heapsort sortiert ein Array mit n Elementen und erfordert
2n log2 n + O(n) Vergleiche.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
50 / 84
Sortieren
Standard Heapsort
Beweis:
Korrektheit: Nach build-heap(n) ist a[1] das maximale Element des
Arrays.
Dieses wird mittels swap(1, n) an seine korrekte Position (n) transportiert.
Nach Induktion wird während der restlichen Laufzeit das Subarray
a[1, . . . , n − 1] sortiert.
Laufzeit: Der Heap-Aufbau erfordert O(n) und der Abbau durch
Einsinken 2n log2 n Vergleiche.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
51 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
1
16
Markus Lohrey (Universität Siegen)
2
3
14
10
4
5
6
7
8
7
9
3
8
9
2
4 1
10
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
16
1
1
Markus Lohrey (Universität Siegen)
2
3
14
10
4
5
6
7
8
7
9
3
8
9
2
4
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
16
1
14
Markus Lohrey (Universität Siegen)
2
3
1
10
4
5
6
7
8
7
9
3
8
9
2
4
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
16
1
14
Markus Lohrey (Universität Siegen)
2
3
8
10
4
5
6
7
1
7
9
3
8
9
2
4
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
16
1
14
Markus Lohrey (Universität Siegen)
2
3
8
10
4
5
6
7
4
7
9
3
8
9
2
1
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
14 16
1
1
2
3
8
10
4
5
6
7
4
7
9
3
8
2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
14 16
1
10
2
3
8
1
4
5
6
7
4
7
9
3
8
2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
14 16
1
10
2
3
8
9
4
5
6
7
4
7
1
3
8
2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
10 14 16
1
2
Markus Lohrey (Universität Siegen)
2
3
8
9
4
5
6
7
4
7
1
3
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
10 14 16
1
9
Markus Lohrey (Universität Siegen)
2
3
8
2
4
5
6
7
4
7
1
3
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
10
10 14 16
1
9
Markus Lohrey (Universität Siegen)
2
3
8
3
4
5
6
7
4
7
1
2
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
9
10
10 14 16
1
2
Markus Lohrey (Universität Siegen)
2
3
8
3
4
5
6
4
7
1
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
9
10
10 14 16
1
8
Markus Lohrey (Universität Siegen)
2
3
2
3
4
5
6
4
7
1
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
9
10
10 14 16
1
8
Markus Lohrey (Universität Siegen)
2
3
7
3
4
5
6
4
2
1
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
8
9
10
10 14 16
1
1
Markus Lohrey (Universität Siegen)
2
3
7
3
4
5
4
2
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
8
9
10
10 14 16
1
7
Markus Lohrey (Universität Siegen)
2
3
1
3
4
5
4
2
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
8
9
8
9
10
10 14 16
1
7
Markus Lohrey (Universität Siegen)
2
3
4
3
4
5
1
2
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
7
8
9
8
9
10
10 14 16
1
2
2
3
4
3
4
1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
7
8
9
8
9
10
10 14 16
1
4
2
3
2
3
4
1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
7
8
9
8
9
10
10 14 16
1
4
2
3
2
3
4
1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
4
7
8
9
8
9
10
10 14 16
1
1
Markus Lohrey (Universität Siegen)
2
3
2
3
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
4
7
8
9
8
9
10
10 14 16
1
3
Markus Lohrey (Universität Siegen)
2
3
2
1
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
3
4
7
8
9
8
9
10
10 14 16
1
1
2
2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
3
4
7
8
9
8
9
10
10 14 16
1
2
2
1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
2
3
4
7
8
9
8
9
10
10 14 16
1
1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
52 / 84
Sortieren
Beispiel für Standard Heapsort
1
2
3
4
5
6
7
1
2
3
4
7
8
9
Markus Lohrey (Universität Siegen)
Algorithmen
8
9
10
10 14 16
WS 2013/2014
52 / 84
Sortieren
Bottom-Up-Heapsort
Bemerkung: Eine Analyse der Durchschnittskomplexität von Heapsort
ergibt einen mittlerer Aufwand von 2n log2 n Vergleichen. Damit ist
Standard-Heapsort zu Quicksort nicht konkurrenzfähig.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
53 / 84
Sortieren
Bottom-Up-Heapsort
Bemerkung: Eine Analyse der Durchschnittskomplexität von Heapsort
ergibt einen mittlerer Aufwand von 2n log2 n Vergleichen. Damit ist
Standard-Heapsort zu Quicksort nicht konkurrenzfähig.
Bottom-Up-Heapsort benötigt wesentlich weniger Vergleiche.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
53 / 84
Sortieren
Bottom-Up-Heapsort
Bemerkung: Eine Analyse der Durchschnittskomplexität von Heapsort
ergibt einen mittlerer Aufwand von 2n log2 n Vergleichen. Damit ist
Standard-Heapsort zu Quicksort nicht konkurrenzfähig.
Bottom-Up-Heapsort benötigt wesentlich weniger Vergleiche.
Nach dem Vertauschen swap(1, i ) wird zuerst der potentielle Einsinkpfad
des Elementes a[i ] bestimmt.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
53 / 84
Sortieren
Bottom-Up-Heapsort
Bemerkung: Eine Analyse der Durchschnittskomplexität von Heapsort
ergibt einen mittlerer Aufwand von 2n log2 n Vergleichen. Damit ist
Standard-Heapsort zu Quicksort nicht konkurrenzfähig.
Bottom-Up-Heapsort benötigt wesentlich weniger Vergleiche.
Nach dem Vertauschen swap(1, i ) wird zuerst der potentielle Einsinkpfad
des Elementes a[i ] bestimmt.
Es wird der Weg verfolgt, der immer zum größeren der beiden Nachfolger
führt (Kosten: nur log n statt 2 log2 n Vergleiche).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
53 / 84
Sortieren
Bottom-Up-Heapsort
Bemerkung: Eine Analyse der Durchschnittskomplexität von Heapsort
ergibt einen mittlerer Aufwand von 2n log2 n Vergleichen. Damit ist
Standard-Heapsort zu Quicksort nicht konkurrenzfähig.
Bottom-Up-Heapsort benötigt wesentlich weniger Vergleiche.
Nach dem Vertauschen swap(1, i ) wird zuerst der potentielle Einsinkpfad
des Elementes a[i ] bestimmt.
Es wird der Weg verfolgt, der immer zum größeren der beiden Nachfolger
führt (Kosten: nur log n statt 2 log2 n Vergleiche).
Da erwartungsgemäß a[i ] tief einsinken wird, bietet sich anschließend eine
bottom-up Bestimmung der tatsächlichen Position auf dem Einsinkpfad an.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
53 / 84
Sortieren
Bottom-Up-Heapsort
Bemerkung: Eine Analyse der Durchschnittskomplexität von Heapsort
ergibt einen mittlerer Aufwand von 2n log2 n Vergleichen. Damit ist
Standard-Heapsort zu Quicksort nicht konkurrenzfähig.
Bottom-Up-Heapsort benötigt wesentlich weniger Vergleiche.
Nach dem Vertauschen swap(1, i ) wird zuerst der potentielle Einsinkpfad
des Elementes a[i ] bestimmt.
Es wird der Weg verfolgt, der immer zum größeren der beiden Nachfolger
führt (Kosten: nur log n statt 2 log2 n Vergleiche).
Da erwartungsgemäß a[i ] tief einsinken wird, bietet sich anschließend eine
bottom-up Bestimmung der tatsächlichen Position auf dem Einsinkpfad an.
Hoffnung: Die bottom-up Bestimmung erfordert insgesamt nur O(n)
Vergleiche.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
53 / 84
Sortieren
Der Einsinkpfad
x0
y2
x1
>
<
x2
y3
<
y1
x3
..
.
xk−1
xk
>
yk
Das Einsinken wird auf dem Pfad [x0 , x1 , x2 , . . . , xk−1 , xk ] geschehen,
welcher mittels log2 n Vergleiche bestimmt werden kann.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
54 / 84
Sortieren
Einsortieren auf dem Einsinkpfad
Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up)
die tatsächliche Position p auf dem Einsinkpfad.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
55 / 84
Sortieren
Einsortieren auf dem Einsinkpfad
Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up)
die tatsächliche Position p auf dem Einsinkpfad.
Ist diese Position p gefunden, so werden die Elemente x0 , . . . , xp zyklisch
vertauscht (x0 geht an die Stelle von xp , und x1 , . . . , xp rutschen hoch).
1
3
Markus Lohrey (Universität Siegen)
2
3
14
10
4
5
6
7
8
7
9
5
8
9
1
2
Algorithmen
WS 2013/2014
55 / 84
Sortieren
Einsortieren auf dem Einsinkpfad
Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up)
die tatsächliche Position p auf dem Einsinkpfad.
Ist diese Position p gefunden, so werden die Elemente x0 , . . . , xp zyklisch
vertauscht (x0 geht an die Stelle von xp , und x1 , . . . , xp rutschen hoch).
1
Markus Lohrey (Universität Siegen)
2
3
14
10
4
5
6
7
8
7
9
5
8
9
1
2 > 3?
Algorithmen
WS 2013/2014
55 / 84
Sortieren
Einsortieren auf dem Einsinkpfad
Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up)
die tatsächliche Position p auf dem Einsinkpfad.
Ist diese Position p gefunden, so werden die Elemente x0 , . . . , xp zyklisch
vertauscht (x0 geht an die Stelle von xp , und x1 , . . . , xp rutschen hoch).
1
2
3
14
10
4
Markus Lohrey (Universität Siegen)
5
6
7
8 > 3? 7
9
5
8
9
1
2
Algorithmen
WS 2013/2014
55 / 84
Sortieren
Einsortieren auf dem Einsinkpfad
Wir bestimmen jetzt vom Blatt des Einsinkpfades aus (also bottom-up)
die tatsächliche Position p auf dem Einsinkpfad.
Ist diese Position p gefunden, so werden die Elemente x0 , . . . , xp zyklisch
vertauscht (x0 geht an die Stelle von xp , und x1 , . . . , xp rutschen hoch).
1
14
Markus Lohrey (Universität Siegen)
2
3
8
10
4
5
6
7
3
7
9
5
8
9
1
2
Algorithmen
WS 2013/2014
55 / 84
Sortieren
Varianten
Es kann gezeigt werden, dass Bottom-up Heapsort
im schlechtesten Fall höchstens 1.5n log n + O(n) Vergleiche benötigt,
und im Durchschnitt nur n log2 n + O(n) Vergleiche benötigt.
Beachte: Die erwartete Höhe eines Knotens in einem Binärbaum mit
zufälliger Knotenverteilung ist:
∞
1
1
1X n
1
=1
0 · + 1 · + 2 · + ··· =
2
4
8
2
2n
n=0
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
56 / 84
Sortieren
Varianten
Es kann gezeigt werden, dass Bottom-up Heapsort
im schlechtesten Fall höchstens 1.5n log n + O(n) Vergleiche benötigt,
und im Durchschnitt nur n log2 n + O(n) Vergleiche benötigt.
Beachte: Die erwartete Höhe eines Knotens in einem Binärbaum mit
zufälliger Knotenverteilung ist:
∞
1
1
1X n
1
=1
0 · + 1 · + 2 · + ··· =
2
4
8
2
2n
n=0
Wenn man nach Carlsson auf dem Pfad eine binäre Suche anwendet, so
kommt man auf einen Aufwand von höchstens n log n + O(n log log n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
56 / 84
Sortieren
Varianten
Es kann gezeigt werden, dass Bottom-up Heapsort
im schlechtesten Fall höchstens 1.5n log n + O(n) Vergleiche benötigt,
und im Durchschnitt nur n log2 n + O(n) Vergleiche benötigt.
Beachte: Die erwartete Höhe eines Knotens in einem Binärbaum mit
zufälliger Knotenverteilung ist:
∞
1
1
1X n
1
=1
0 · + 1 · + 2 · + ··· =
2
4
8
2
2n
n=0
Wenn man nach Carlsson auf dem Pfad eine binäre Suche anwendet, so
kommt man auf einen Aufwand von höchstens n log n + O(n log log n).
Eine binäre Suche ist aber in der Praxis zu aufwendig und außerdem steigt
man in den Pfad i.A. zu hoch ein.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
56 / 84
Greedy-Algorithmen
Greedy-Algorithmen
Greedy ( gierig“) bezeichnet Lösungsstrategien, die auf der schrittweisen
”
Berechnung von Teillösungen (lokalen Optima) basieren.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
57 / 84
Greedy-Algorithmen
Greedy-Algorithmen
Greedy ( gierig“) bezeichnet Lösungsstrategien, die auf der schrittweisen
”
Berechnung von Teillösungen (lokalen Optima) basieren.
Dieses Verfahren eignet sich für Probleme, bei denen jede Teilfolge einer
optimalen Folge auch optimal ist (Optimalitätsprinzip).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
57 / 84
Greedy-Algorithmen
Kürzeste Wege
Klassisches Beispiel für die Greedy-Strategie: Bestimmung kürzester Wege
in einem Kanten-gewichteten Graphen G = (V , E , γ).
V ist die Knotenmenge.
E ⊆ V × V ist die Kantenmenge.
γ : E → N ist die Gewichtsfunktion.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
58 / 84
Greedy-Algorithmen
Kürzeste Wege
Klassisches Beispiel für die Greedy-Strategie: Bestimmung kürzester Wege
in einem Kanten-gewichteten Graphen G = (V , E , γ).
V ist die Knotenmenge.
E ⊆ V × V ist die Kantenmenge.
γ : E → N ist die Gewichtsfunktion.
Gewicht eines Pfades (v0 , v1 , v2 , . . . , vn ):
n−1
X
γ(vi , vi +1 )
i =0
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
58 / 84
Greedy-Algorithmen
Kürzeste Wege
Klassisches Beispiel für die Greedy-Strategie: Bestimmung kürzester Wege
in einem Kanten-gewichteten Graphen G = (V , E , γ).
V ist die Knotenmenge.
E ⊆ V × V ist die Kantenmenge.
γ : E → N ist die Gewichtsfunktion.
Gewicht eines Pfades (v0 , v1 , v2 , . . . , vn ):
n−1
X
γ(vi , vi +1 )
i =0
Für u, v ∈ V ist d(u, v ) das Minimum der Gewichte aller Pfade von u nach
v (d(u, v ) = ∞, falls kein Pfad von u nach v existiert, und d(u, u) = 0).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
58 / 84
Greedy-Algorithmen
Kürzeste Wege
Klassisches Beispiel für die Greedy-Strategie: Bestimmung kürzester Wege
in einem Kanten-gewichteten Graphen G = (V , E , γ).
V ist die Knotenmenge.
E ⊆ V × V ist die Kantenmenge.
γ : E → N ist die Gewichtsfunktion.
Gewicht eines Pfades (v0 , v1 , v2 , . . . , vn ):
n−1
X
γ(vi , vi +1 )
i =0
Für u, v ∈ V ist d(u, v ) das Minimum der Gewichte aller Pfade von u nach
v (d(u, v ) = ∞, falls kein Pfad von u nach v existiert, und d(u, u) = 0).
Ziel: Gegeben G = (V , E , γ) und Startknoten u ∈ V , berechne für jedes
v ∈ V einen Pfad u = v0 , v1 , v2 , . . . , vn−1 , vn = v mit minimalem Gewicht
d(u, v ).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
58 / 84
Greedy-Algorithmen
Dijkstra-Algorithmus
B := ∅ (Baumknoten); R := {u} (Rand); U := V \ {u} (unbekannt);
p(u) := nil; D(u) := 0;
while R 6= ∅ do
x := nil; α := ∞;
forall y ∈ R do
if D(y ) < α then
x := y ; α := D(y )
endif
endfor
B := B ∪ {x}; R := R \ {x}
forall (x, y ) ∈ E do
if y ∈ U then
D(y ) := D(x) + γ(x, y ); p(y ) := x; U := U \ {y }; R := R ∪ {y }
elsif y ∈ R and D(x) + γ(x, y ) < D(y ) then
D(y ) := D(x) + γ(x, y ); p(y ) := x
endif
endfor
endwhile
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
59 / 84
Greedy-Algorithmen
Beispiel Dijkstra-Algorithmus
Baumknoten
source node
0
1
1
Rand
6
3
∞
3
8
2
13
4
∞
∞
3
unbekannte Knoten
6
∞
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
60 / 84
Greedy-Algorithmen
Beispiel Dijkstra-Algorithmus
Baumknoten
Startknoten
0
1
1
Rand
6
3
7
3
8
2
13
4
∞
∞
3
unbekannte Knoten
6
14
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
60 / 84
Greedy-Algorithmen
Beispiel Dijkstra-Algorithmus
Baumknoten
Startknoten
0
1
1
Rand
6
3
7
3
8
2
13
4
11
7
3
unbekannte Knoten
6
14
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
60 / 84
Greedy-Algorithmen
Beispiel Dijkstra-Algorithmus
Baumknoten
Startknoten
0
1
1
Rand
6
3
7
3
8
2
13
4
11
7
3
unbekannte Knoten
6
13
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
60 / 84
Greedy-Algorithmen
Beispiel Dijkstra-Algorithmus
Baumknoten
Startknoten
0
1
1
Rand
6
3
7
3
8
2
13
4
9
7
3
unbekannte Knoten
6
13
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
60 / 84
Greedy-Algorithmen
Beispiel Dijkstra-Algorithmus
Baumknoten
Startknoten
0
1
1
Rand
6
3
7
3
8
2
13
4
9
7
3
unbekannte Knoten
6
12
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
60 / 84
Greedy-Algorithmen
Beispiel Dijkstra-Algorithmus
Baumknoten
Startknoten
0
1
1
Rand
6
3
7
3
8
2
13
4
9
7
3
unbekannte Knoten
6
12
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
60 / 84
Greedy-Algorithmen
Korrektheit von Dijkstras Algorithmus
Theorem 9 (Korrektheit von Dijkstras Algorithmus)
Der Dijkstra–Algorithmus berechnet alle kürzesten Pfade von einer Quelle
aus im schlechtesten Fall.
Beweis:
Bemerkung: Der Dijkstra-Algorithmus liefert nicht notwendigerweise ein
korrektes Ergebnis, falls negative Kantengewichte erlaubt werden.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
61 / 84
Greedy-Algorithmen
Dijkstra mit abstrakten Datentyp für Rand
Um die Laufzeit von Dijkstras Algorithmus zu analysieren, ist es nützlich
ihn mit einem abstrakten Datentyp für den Rand R zu formulieren.
Folgende Operationen werden für den Rand R benötigt:
insert
decrease-key
delete-min
Füge ein neues Element in R ein.
Verringere den Schlüsselwert eines Elements von R
(und erhalte die Eigenschaften des Datentyps R).
Suche ein Element mit minimalem Schlüsselwert
und entferne dieses aus R (und erhalte die Eigenschaften des Datentyps R).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
62 / 84
Greedy-Algorithmen
Dijkstra mit abstrakten Datentyp für Rank
B := ∅; R := {u}; U := V \ {u}; p(u) := nil; D(u) := 0;
while (R 6= ∅) do
x := delete-min(R);
B := B ∪ {x};
forall (x, y ) ∈ E do
if y ∈ U then
U := U \ {y }; p(y ) := x; D(y ) := D(x) + γ(x, y );
insert(R, y , D(y ));
elsif D(x) + γ(x, y ) < D(y ) then
p(y ) := x; D(y ) := D(x) + γ(x, y );
decrease-key(R, y , D(y ));
endif
endfor
endwhile
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
63 / 84
Greedy-Algorithmen
Laufzeit von Dijkstras Algorithmus
Anzahl der Operationen (n = Anzahl der Knoten, e = Anzahl der Kanten):
insert
decrease-key
delete-min
n
e
n
Die Laufzeit hängt von der für den Rand verwendeten Datenstruktur ab:
1
2
Arrays der Größe n:
einzelnes insert/decrease-key: O(1)
einzelnes delete-min: O(n)
resultierende Laufzeit: O(n + e + n2 ) = O(n2 )
Heap (balancierter Binärbaum der Tiefe O(log(n)):
einzelnes insert/decrease-key/delete-min: O(log(n))
resultierende Laufzeit: O(n log(n) + e log(n)) = O(e log(n)).
Falls O(e) ⊆ o(n2 / log n) gilt, ist ein Heap also besser als ein Array.
Für planare Graphen gilt etwa e ≤ 3n − 6 für n ≥ 3
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
64 / 84
Datenstrukturen
Fibonacci Heap
Fibonacci Heaps schlagen sowohl Arrays als auch Heaps: O(e + n log n)
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
65 / 84
Datenstrukturen
Fibonacci Heap
Fibonacci Heaps schlagen sowohl Arrays als auch Heaps: O(e + n log n)
A Fibonacci heap H is a list of rooted trees, i.e., a forest.
V is the set of nodes.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
65 / 84
Datenstrukturen
Fibonacci Heap
Fibonacci Heaps schlagen sowohl Arrays als auch Heaps: O(e + n log n)
A Fibonacci heap H is a list of rooted trees, i.e., a forest.
V is the set of nodes.
Every node v ∈ V is labeled with a value key (v ) ∈ N.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
65 / 84
Datenstrukturen
Fibonacci Heap
Fibonacci Heaps schlagen sowohl Arrays als auch Heaps: O(e + n log n)
A Fibonacci heap H is a list of rooted trees, i.e., a forest.
V is the set of nodes.
Every node v ∈ V is labeled with a value key (v ) ∈ N.
Heap condition: ∀x ∈ V : y is a child of x ⇒ key (x) ≤ key (y )
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
65 / 84
Datenstrukturen
Fibonacci Heap
Fibonacci Heaps schlagen sowohl Arrays als auch Heaps: O(e + n log n)
A Fibonacci heap H is a list of rooted trees, i.e., a forest.
V is the set of nodes.
Every node v ∈ V is labeled with a value key (v ) ∈ N.
Heap condition: ∀x ∈ V : y is a child of x ⇒ key (x) ≤ key (y )
Some of the nodes in V will be marked. A root of a tree will never be
marked.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
65 / 84
Datenstrukturen
Fibonacci Heaps
Example for a Fibonacci heap (keys are inside the circles, marked nodes
are gray)
23
7
21
3
18
52
39
Markus Lohrey (Universität Siegen)
Algorithmen
17
38
41
30
24
26
46
35
WS 2013/2014
66 / 84
Datenstrukturen
Fibonacci Heaps
The parent-child relation is realized by pointers, because trees are not
balanced.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
67 / 84
Datenstrukturen
Fibonacci Heaps
The parent-child relation is realized by pointers, because trees are not
balanced.
Thus, pointer manipulations replace the index calculations in standard
heaps.
Operations:
1
2
3
4
merge
insert
delete-min
decrease-key
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
67 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of merge and insert
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
68 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of merge and insert
merge: concatenate two lists — constant time
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
68 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of merge and insert
merge: concatenate two lists — constant time
insert: special case of merge — constant time
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
68 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of merge and insert
merge: concatenate two lists — constant time
insert: special case of merge — constant time
merge and insert produce eventually long lists of one-node trees.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
68 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of merge and insert
merge: concatenate two lists — constant time
insert: special case of merge — constant time
merge and insert produce eventually long lists of one-node trees.
Every such list is a Fibonacci heap.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
68 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
69 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
Let H be a Fibonacci heap consisting of T trees and n nodes.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
69 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
Let H be a Fibonacci heap consisting of T trees and n nodes.
For a node x ∈ V let rank(x) be the number of children of x.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
69 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
Let H be a Fibonacci heap consisting of T trees and n nodes.
For a node x ∈ V let rank(x) be the number of children of x.
For a tree B in H let rank(B) be the rank of the root of B.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
69 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
Let H be a Fibonacci heap consisting of T trees and n nodes.
For a node x ∈ V let rank(x) be the number of children of x.
For a tree B in H let rank(B) be the rank of the root of B.
Let rmax (n) be the maximal rank that may appear in a Fibonacci heap
with n nodes.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
69 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
Let H be a Fibonacci heap consisting of T trees and n nodes.
For a node x ∈ V let rank(x) be the number of children of x.
For a tree B in H let rank(B) be the rank of the root of B.
Let rmax (n) be the maximal rank that may appear in a Fibonacci heap
with n nodes.
Clearly rmax (n) ≤ n, later we will show rmax (n) ∈ O(log n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
69 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
Search the root x with minimal key. Time: O(T )
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
3
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Define an array L[0, . . . , rmax (n)], where L[i ] is the list of all trees of
rank i . Time: O(T + rmax (n)).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
3
4
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Define an array L[0, . . . , rmax (n)], where L[i ] is the list of all trees of
rank i . Time: O(T + rmax (n)).
for i := 0 to rmax (n) − 1 do
while |L[i ]| ≥ 2 do
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
3
4
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Define an array L[0, . . . , rmax (n)], where L[i ] is the list of all trees of
rank i . Time: O(T + rmax (n)).
for i := 0 to rmax (n) − 1 do
while |L[i ]| ≥ 2 do
remove two trees from L[i ]
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
3
4
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Define an array L[0, . . . , rmax (n)], where L[i ] is the list of all trees of
rank i . Time: O(T + rmax (n)).
for i := 0 to rmax (n) − 1 do
while |L[i ]| ≥ 2 do
remove two trees from L[i ]
make root with larger key a new child of the other root
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
3
4
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Define an array L[0, . . . , rmax (n)], where L[i ] is the list of all trees of
rank i . Time: O(T + rmax (n)).
for i := 0 to rmax (n) − 1 do
while |L[i ]| ≥ 2 do
remove two trees from L[i ]
make root with larger key a new child of the other root
add resulting new tree to L[i + 1]
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
3
4
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Define an array L[0, . . . , rmax (n)], where L[i ] is the list of all trees of
rank i . Time: O(T + rmax (n)).
for i := 0 to rmax (n) − 1 do
while |L[i ]| ≥ 2 do
remove two trees from L[i ]
make root with larger key a new child of the other root
add resulting new tree to L[i + 1]
endwhile endfor
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of delete-min
1
2
3
4
Search the root x with minimal key. Time: O(T )
Remove x and replace the tree rooted at x by its rank(x) many
subtrees. Remove markings from the new roots. Time:
O(rank(x)) ⊆ O(rmax (n)).
Define an array L[0, . . . , rmax (n)], where L[i ] is the list of all trees of
rank i . Time: O(T + rmax (n)).
for i := 0 to rmax (n) − 1 do
while |L[i ]| ≥ 2 do
remove two trees from L[i ]
make root with larger key a new child of the other root
add resulting new tree to L[i + 1]
endwhile endfor
Time: O(T + rmax (n))
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
70 / 84
Datenstrukturen
Fibonacci Heaps
Example for delete-min:
23
7
21
3
18
39
Markus Lohrey (Universität Siegen)
52
17
38
41
Algorithmen
30
24
26
46
35
WS 2013/2014
71 / 84
Datenstrukturen
Fibonacci Heaps
Example for delete-min:
23
7
21
18
39
52
38
17
41
30
24
26
46
35
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
71 / 84
Datenstrukturen
Fibonacci Heaps
Example for delete-min:
7
21
23
18
39
52
38
17
41
30
24
26
46
35
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
71 / 84
Datenstrukturen
Fibonacci Heaps
Example for delete-min:
7
21
18
38
17
23
52
39
41
30
24
26
46
35
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
71 / 84
Datenstrukturen
Fibonacci Heaps
Example for delete-min:
7
23
21
18
38
17
39
41
30
52
Markus Lohrey (Universität Siegen)
24
26
46
35
Algorithmen
WS 2013/2014
71 / 84
Datenstrukturen
Fibonacci Heaps
Example for delete-min:
7
23
18
21
52
Markus Lohrey (Universität Siegen)
39
17
38
41
Algorithmen
30
24
26
46
35
WS 2013/2014
71 / 84
Datenstrukturen
Fibonacci Heaps
Example for delete-min:
7
23
17
21
18
52
39
30
38
24
26
46
35
41
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
71 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to delete-min
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
72 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to delete-min
delete-min needs time O(T + rmax (n)), where T is the number of
trees before the operation.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
72 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to delete-min
delete-min needs time O(T + rmax (n)), where T is the number of
trees before the operation.
At the end of delete-min, there is for every i at most one tree of
rank i .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
72 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to delete-min
delete-min needs time O(T + rmax (n)), where T is the number of
trees before the operation.
At the end of delete-min, there is for every i at most one tree of
rank i .
In particular, the number of trees is bounded by rmax (n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
72 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of decrease-key: Let x be the node for which the key has
to be decreased.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
73 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of decrease-key: Let x be the node for which the key has
to be decreased.
1
If x is a root, then we can decrease key (x) without any other
changes. Thus, assume that x is not a root and let x = y0 , y1 , . . . , ym
be the path from x to a root ym (m ≥ 1).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
73 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of decrease-key: Let x be the node for which the key has
to be decreased.
1
If x is a root, then we can decrease key (x) without any other
changes. Thus, assume that x is not a root and let x = y0 , y1 , . . . , ym
be the path from x to a root ym (m ≥ 1).
Let yk (1 ≤ k ≤ m) be the first node on this path that is different
from x and that is not marked (note that ym is not marked).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
73 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of decrease-key: Let x be the node for which the key has
to be decreased.
1
If x is a root, then we can decrease key (x) without any other
changes. Thus, assume that x is not a root and let x = y0 , y1 , . . . , ym
be the path from x to a root ym (m ≥ 1).
Let yk (1 ≤ k ≤ m) be the first node on this path that is different
from x and that is not marked (note that ym is not marked).
2
For 0 ≤ i < k we cut off yi from its parent node yi +1 and remove the
marking from yi (y0 = x may be marked).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
73 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of decrease-key: Let x be the node for which the key has
to be decreased.
1
If x is a root, then we can decrease key (x) without any other
changes. Thus, assume that x is not a root and let x = y0 , y1 , . . . , ym
be the path from x to a root ym (m ≥ 1).
Let yk (1 ≤ k ≤ m) be the first node on this path that is different
from x and that is not marked (note that ym is not marked).
2
For 0 ≤ i < k we cut off yi from its parent node yi +1 and remove the
marking from yi (y0 = x may be marked).
Thus, yi (0 ≤ i < k) will be a (unmarked) root of a new tree.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
73 / 84
Datenstrukturen
Fibonacci Heaps
Implementation of decrease-key: Let x be the node for which the key has
to be decreased.
1
If x is a root, then we can decrease key (x) without any other
changes. Thus, assume that x is not a root and let x = y0 , y1 , . . . , ym
be the path from x to a root ym (m ≥ 1).
Let yk (1 ≤ k ≤ m) be the first node on this path that is different
from x and that is not marked (note that ym is not marked).
2
For 0 ≤ i < k we cut off yi from its parent node yi +1 and remove the
marking from yi (y0 = x may be marked).
Thus, yi (0 ≤ i < k) will be a (unmarked) root of a new tree.
3
If yk is not a root we mark yk (and remember in this way that yk lost
a child).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
73 / 84
Datenstrukturen
Fibonacci Heaps
7
23
17
21
18
52
39
30
38
24
26
46
35
41
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
74 / 84
Datenstrukturen
Fibonacci Heaps
decrease-key(node with key 39, 6)
7
23
17
21
18
52
39
30
38
24
26
46
35
41
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
74 / 84
Datenstrukturen
Fibonacci Heaps
decrease-key(node with key 39, 6)
7
23
6
21
52
18
17
30
38
24
26
46
35
41
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
74 / 84
Datenstrukturen
Fibonacci Heaps
decrease-key(node with key 38, 29)
7
23
6
21
52
18
17
30
38
24
26
46
35
41
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
74 / 84
Datenstrukturen
Fibonacci Heaps
decrease-key(node with key 38, 29)
7
23
29
21
18
6
41
52
Markus Lohrey (Universität Siegen)
17
30
24
26
46
35
Algorithmen
WS 2013/2014
74 / 84
Datenstrukturen
Fibonacci Heaps
decrease-key(node with key 38, 29)
7
23
18
21
29
6
41
52
Markus Lohrey (Universität Siegen)
17
30
24
26
46
35
Algorithmen
WS 2013/2014
74 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to decrease-key:
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
75 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to decrease-key:
Time: O(k) + O(1)
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
75 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to decrease-key:
Time: O(k) + O(1)
decrease-key reduces the number of marked nodes by at least k − 2
(k ≥ 1).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
75 / 84
Datenstrukturen
Fibonacci Heaps
Remarks to decrease-key:
Time: O(k) + O(1)
decrease-key reduces the number of marked nodes by at least k − 2
(k ≥ 1).
decrease-key increases the number of trees by k.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
75 / 84
Datenstrukturen
Fibonacci Heaps
Definition 10
A Fibonacci heap is a list of rooted trees as described earlier that can be
obtained from the empty list by applying
merge/insert/delete-min/decrease-key-operations.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
76 / 84
Datenstrukturen
Fibonacci Heaps
Definition 10
A Fibonacci heap is a list of rooted trees as described earlier that can be
obtained from the empty list by applying
merge/insert/delete-min/decrease-key-operations.
Fibonacci heaps-lemma: Let x be a node in a Fibonacci heap with
rank(x) = k
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
76 / 84
Datenstrukturen
Fibonacci Heaps
Definition 10
A Fibonacci heap is a list of rooted trees as described earlier that can be
obtained from the empty list by applying
merge/insert/delete-min/decrease-key-operations.
Fibonacci heaps-lemma: Let x be a node in a Fibonacci heap with
rank(x) = k
1
If c1 , . . . , ck are the children of x and ci became a child of x before
ci +1 became a child of x, then rank(ci ) ≥ i − 2.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
76 / 84
Datenstrukturen
Fibonacci Heaps
Definition 10
A Fibonacci heap is a list of rooted trees as described earlier that can be
obtained from the empty list by applying
merge/insert/delete-min/decrease-key-operations.
Fibonacci heaps-lemma: Let x be a node in a Fibonacci heap with
rank(x) = k
1
2
If c1 , . . . , ck are the children of x and ci became a child of x before
ci +1 became a child of x, then rank(ci ) ≥ i − 2.
The subtree rooted at x contains at least Fk+1 nodes. Here Fk+1 is
the (k + 1)-th Fibonacci number (F0 = F1 = 1, Fk+1 = Fk + Fk−1 for
k ≥ 1).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
76 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
77 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 1
At the time, when ci became a child of x, the nodes c1 , . . . , ci −1 were
already children of x, thus x had rank at least i − 1 at that time.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
77 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 1
At the time, when ci became a child of x, the nodes c1 , . . . , ci −1 were
already children of x, thus x had rank at least i − 1 at that time.
Since only trees of equal ranks are merged into a single tree, the rank of ci
was at least i − 1 at that time.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
77 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 1
At the time, when ci became a child of x, the nodes c1 , . . . , ci −1 were
already children of x, thus x had rank at least i − 1 at that time.
Since only trees of equal ranks are merged into a single tree, the rank of ci
was at least i − 1 at that time.
In the meantime, node ci may have lost at most one child (if it looses a
child, then ci becomes marked, if ci would loose a second child, then ci
would be cut off from x).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
77 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 1
At the time, when ci became a child of x, the nodes c1 , . . . , ci −1 were
already children of x, thus x had rank at least i − 1 at that time.
Since only trees of equal ranks are merged into a single tree, the rank of ci
was at least i − 1 at that time.
In the meantime, node ci may have lost at most one child (if it looses a
child, then ci becomes marked, if ci would loose a second child, then ci
would be cut off from x).
Thus, rank(ci ) ≥ i − 2.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
77 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 2
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
78 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 2
Let Bk be the minimal number of nodes in a subtree of rank k in a
Fibonacci heap. We show that Bk ≥ Fk+1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
78 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 2
Let Bk be the minimal number of nodes in a subtree of rank k in a
Fibonacci heap. We show that Bk ≥ Fk+1
For k = 0 and k = 1 this is true: B0 ≥ 1 = F1 , B1 ≥ 2 = F2 .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
78 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 2
Let Bk be the minimal number of nodes in a subtree of rank k in a
Fibonacci heap. We show that Bk ≥ Fk+1
For k = 0 and k = 1 this is true: B0 ≥ 1 = F1 , B1 ≥ 2 = F2 .
Now assume that x is a node with rank(x) = k + 1 and Bk+1 many nodes
in the subtree rooted at x.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
78 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 2
Let Bk be the minimal number of nodes in a subtree of rank k in a
Fibonacci heap. We show that Bk ≥ Fk+1
For k = 0 and k = 1 this is true: B0 ≥ 1 = F1 , B1 ≥ 2 = F2 .
Now assume that x is a node with rank(x) = k + 1 and Bk+1 many nodes
in the subtree rooted at x.
Note: j ≥ i ⇒ Bj ≥ Bi .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
78 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 2
Let Bk be the minimal number of nodes in a subtree of rank k in a
Fibonacci heap. We show that Bk ≥ Fk+1
For k = 0 and k = 1 this is true: B0 ≥ 1 = F1 , B1 ≥ 2 = F2 .
Now assume that x is a node with rank(x) = k + 1 and Bk+1 many nodes
in the subtree rooted at x.
Note: j ≥ i ⇒ Bj ≥ Bi .
Let c1 , . . . , ck+1 be the children of x ordered by descending age.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
78 / 84
Datenstrukturen
Fibonacci Heaps
Proof of the Fibonacci heaps-lemma, part 2
Let Bk be the minimal number of nodes in a subtree of rank k in a
Fibonacci heap. We show that Bk ≥ Fk+1
For k = 0 and k = 1 this is true: B0 ≥ 1 = F1 , B1 ≥ 2 = F2 .
Now assume that x is a node with rank(x) = k + 1 and Bk+1 many nodes
in the subtree rooted at x.
Note: j ≥ i ⇒ Bj ≥ Bi .
Let c1 , . . . , ck+1 be the children of x ordered by descending age.
From the previous note and part 1 of the lemma, we obtain:
Bk+1 ≥ 2 +
k+1
X
i =2
Bi −2 ≥ 2 +
Markus Lohrey (Universität Siegen)
k+1
X
Fi −1 = 2 +
i =2
Algorithmen
k
X
Fi = Fk+2
i =1
WS 2013/2014
78 / 84
Datenstrukturen
Fibonacci Heaps
Theorem 11
For k ≥ 0 we have:
1
Fk = √
5
√ !k+1
1+ 5
1
−√
2
5
Markus Lohrey (Universität Siegen)
√ !k+1
1− 5
2
Algorithmen
WS 2013/2014
79 / 84
Datenstrukturen
Fibonacci Heaps
Theorem 11
For k ≥ 0 we have:
1
Fk = √
5
√ !k+1
1+ 5
1
−√
2
5
√ !k+1
1− 5
2
Thus, the Fibonacci numbers grow exponentialy.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
79 / 84
Datenstrukturen
Fibonacci Heaps
Theorem 11
For k ≥ 0 we have:
1
Fk = √
5
√ !k+1
1+ 5
1
−√
2
5
√ !k+1
1− 5
2
Thus, the Fibonacci numbers grow exponentialy.
Consequence: rmax (n) ∈ O(log n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
79 / 84
Datenstrukturen
Fibonacci Heaps
Summary of running times:
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
80 / 84
Datenstrukturen
Fibonacci Heaps
Summary of running times:
merge, insert: constant time
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
80 / 84
Datenstrukturen
Fibonacci Heaps
Summary of running times:
merge, insert: constant time
delete-min: O(T + rmax (n)) ⊆ O(T + log n), where T is the current
number of trees.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
80 / 84
Datenstrukturen
Fibonacci Heaps
Summary of running times:
merge, insert: constant time
delete-min: O(T + rmax (n)) ⊆ O(T + log n), where T is the current
number of trees.
decrease-key: O(1) + O(k) (k ≥ 1), where at least k − 2 markings
are removed from the Fibonacci heap.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
80 / 84
Datenstrukturen
Fibonacci Heaps
Amortized times
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
81 / 84
Datenstrukturen
Fibonacci Heaps
Amortized times
Definition 12
For a Fibonacci heap H, we define its potential pot (H) as
pot (H) := T + 2M, where T is the number of trees and M is the number
of marked nodes.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
81 / 84
Datenstrukturen
Fibonacci Heaps
Amortized times
Definition 12
For a Fibonacci heap H, we define its potential pot (H) as
pot (H) := T + 2M, where T is the number of trees and M is the number
of marked nodes.
For an operation op let ∆pot (op ) be the difference in the potential before
and after the execution of this operation:
∆pot (op ) = pot (heap after op ) − pot (heap before op ) .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
81 / 84
Datenstrukturen
Fibonacci Heaps
Amortized times
Definition 12
For a Fibonacci heap H, we define its potential pot (H) as
pot (H) := T + 2M, where T is the number of trees and M is the number
of marked nodes.
For an operation op let ∆pot (op ) be the difference in the potential before
and after the execution of this operation:
∆pot (op ) = pot (heap after op ) − pot (heap before op ) .
The amortized time of an operation op is
tamort (op ) = t(op ) + ∆pot (op ) .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
81 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
pot (H) ≥ 0
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
pot (H) ≥ 0
pot (H) ∈ O(|H|)
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
pot (H) ≥ 0
pot (H) ∈ O(|H|)
pot (nil) = 0
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
pot (H) ≥ 0
pot (H) ∈ O(|H|)
pot (nil) = 0
Now assume that op 1 , op 2 , op 3 , . . . , op m is a sequence of m operations
that are applied to an initially empty Fibonacci heap.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
pot (H) ≥ 0
pot (H) ∈ O(|H|)
pot (nil) = 0
Now assume that op 1 , op 2 , op 3 , . . . , op m is a sequence of m operations
that are applied to an initially empty Fibonacci heap.
Then we have:
m
X
i =1
t(op i ) ≤
m
X
tamort (op i ) .
i =1
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
pot (H) ≥ 0
pot (H) ∈ O(|H|)
pot (nil) = 0
Now assume that op 1 , op 2 , op 3 , . . . , op m is a sequence of m operations
that are applied to an initially empty Fibonacci heap.
Then we have:
m
X
i =1
t(op i ) ≤
m
X
tamort (op i ) .
i =1
Remark: The difference between the two sums above is precisely the
potential of the generated Fibonacci heap.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
The potential satisfies the following properties:
pot (H) ≥ 0
pot (H) ∈ O(|H|)
pot (nil) = 0
Now assume that op 1 , op 2 , op 3 , . . . , op m is a sequence of m operations
that are applied to an initially empty Fibonacci heap.
Then we have:
m
X
i =1
t(op i ) ≤
m
X
tamort (op i ) .
i =1
Remark: The difference between the two sums above is precisely the
potential of the generated Fibonacci heap.
Thus, it suffices to prove a bound for tamort (op ).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
82 / 84
Datenstrukturen
Fibonacci Heaps
Convention.
By multiplying all further calculations with a suitable constant, we may
assume that merge und insert needs only one time step, that delete-min
needs T + log n time steps, and that decrease-key needs k + 1 time
steps. This allows to skip the O-notation.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
83 / 84
Datenstrukturen
Fibonacci Heaps
tamort (merge) = t(merge) = 1, because the potential of the resulting
concatenated list is the sum of the potentials of the two argument
lists.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
84 / 84
Datenstrukturen
Fibonacci Heaps
tamort (merge) = t(merge) = 1, because the potential of the resulting
concatenated list is the sum of the potentials of the two argument
lists.
tamort (insert) = t(insert)+∆pot (op ) = 1 + 1 = 2.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
84 / 84
Datenstrukturen
Fibonacci Heaps
tamort (merge) = t(merge) = 1, because the potential of the resulting
concatenated list is the sum of the potentials of the two argument
lists.
tamort (insert) = t(insert)+∆pot (op ) = 1 + 1 = 2.
For delete-min we have t(delete-min) ≤ T + log n, where T is the
number of trees before applying delete-min.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
84 / 84
Datenstrukturen
Fibonacci Heaps
tamort (merge) = t(merge) = 1, because the potential of the resulting
concatenated list is the sum of the potentials of the two argument
lists.
tamort (insert) = t(insert)+∆pot (op ) = 1 + 1 = 2.
For delete-min we have t(delete-min) ≤ T + log n, where T is the
number of trees before applying delete-min.
After delete-min, the number of trees is bounded by rmax (n).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
84 / 84
Datenstrukturen
Fibonacci Heaps
tamort (merge) = t(merge) = 1, because the potential of the resulting
concatenated list is the sum of the potentials of the two argument
lists.
tamort (insert) = t(insert)+∆pot (op ) = 1 + 1 = 2.
For delete-min we have t(delete-min) ≤ T + log n, where T is the
number of trees before applying delete-min.
After delete-min, the number of trees is bounded by rmax (n).
The number of marked nodes can only decrease.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
84 / 84
Datenstrukturen
Fibonacci Heaps
tamort (merge) = t(merge) = 1, because the potential of the resulting
concatenated list is the sum of the potentials of the two argument
lists.
tamort (insert) = t(insert)+∆pot (op ) = 1 + 1 = 2.
For delete-min we have t(delete-min) ≤ T + log n, where T is the
number of trees before applying delete-min.
After delete-min, the number of trees is bounded by rmax (n).
The number of marked nodes can only decrease.
Thus, ∆pot (op ) ≤ rmax (n) − T and
tamort (delete min) ≤ T + log n − T + rmax (n) ∈ O(log n) .
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
84 / 84
Datenstrukturen
Fibonacci Heaps
For decrease-key we have t(decrease-key) ≤ k + 1 (k ≥ 1), where
at least k − 2 markings are removed. Moreover k new trees are added
to the Fibonacci heap.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
85 / 84
Datenstrukturen
Fibonacci Heaps
For decrease-key we have t(decrease-key) ≤ k + 1 (k ≥ 1), where
at least k − 2 markings are removed. Moreover k new trees are added
to the Fibonacci heap.
Thus,
∆pot (op ) = ∆(T ) + 2∆(M)
≤ k + 2 · (2 − k)
= 4−k.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
85 / 84
Datenstrukturen
Fibonacci Heaps
For decrease-key we have t(decrease-key) ≤ k + 1 (k ≥ 1), where
at least k − 2 markings are removed. Moreover k new trees are added
to the Fibonacci heap.
Thus,
∆pot (op ) = ∆(T ) + 2∆(M)
≤ k + 2 · (2 − k)
= 4−k.
Thus, tamort (decrease-key) ≤ k + 1 + 4 − k = 5 ∈ O(1).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
85 / 84
Datenstrukturen
Fibonacci Heaps
Theorem 13
For a Fibonacci heap, the following amortized time bounds hold:
tamort (merge) ∈ O(1)
tamort (insert) ∈ O(1)
tamort (delete-min) ∈ O(log n)
tamort (decrease-key) ∈ O(1)
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
86 / 84
Datenstrukturen
Fibonacci Heaps
Back to Dijkstra’s algorithm:
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
87 / 84
Datenstrukturen
Fibonacci Heaps
Back to Dijkstra’s algorithm:
For Dijkstra’s algorithm let V be the boundary, and key (v ) the current
estimation for d(u, v ).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
87 / 84
Datenstrukturen
Fibonacci Heaps
Back to Dijkstra’s algorithm:
For Dijkstra’s algorithm let V be the boundary, and key (v ) the current
estimation for d(u, v ).
Let n be the number of nodes and e be the number of edges in the input
graph. Then, at most n insert-, e decrease-key- and n
delete-min-operations will be executed.
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
87 / 84
Datenstrukturen
Fibonacci Heaps
tDijkstra ≤
n · tamort (insert)
+ e · tamort (decrease-key)
+ n · tamort (delete-min)
∈ O(n + e + n log n)
= O(e + n log n)
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
88 / 84
Datenstrukturen
Fibonacci Heaps
tDijkstra ≤
n · tamort (insert)
+ e · tamort (decrease-key)
+ n · tamort (delete-min)
∈ O(n + e + n log n)
= O(e + n log n)
Recall:
For arrays we got tDijkstra ∈ O(n2 ).
For standard heaps we got tDijkstra ∈ O(e log(n)).
Markus Lohrey (Universität Siegen)
Algorithmen
WS 2013/2014
88 / 84

Zugehörige Unterlagen

Modul Grundlagen der Informatik I Bezeichnung I

Algorithmen - informatik.uni

Zugehörige Unterlagen

Produkte

Unterstützung

Algorithmen - informatik.uni

Zugehörige Unterlagen

Dieses Dokument Sammlung (en)

Dieses Dokument gespeichert

Schlagen Sie uns vor, wie wir StudyLib verbessern können