Document

Höhere Datenstrukturen
Binomial Heaps
Fibonacci Heaps
Neven Santrac
Heiko Ehrig
SoSe 2005 Seminar über Algorithmen
Prof. Helmut Alt
Inhalt
• Binomial Heap
– Binomial Trees
• Definition, Beispiel, Eigenschaften
– Binomial Heap
• Definition, Beispiel, Implementierung
– Operationen
•
•
•
•
•
•
•
Make-Binomial-Heap
Binomial-Heap-Min
Binomial-Heap-Union
Binomial-Heap-Insert
Binomial-Heap-Extract-Min
Binomial-Decrease-Key
Binomial-Heap-Delete
Inhalt
• Amortisierte Analyse: Potentialmethode
• Fibonacci Heap
– Definition, Beispiel, Implementierung
– Operationen
•
•
•
•
•
•
•
Make-Fib-Heap
Fib-Heap-Min
Fib-Heap-Union
Fib-Heap-Insert
Fib-Heap-Extract-Min
Fib-Heap-Decrease-Key
Fib-Heap-Delete
Binomial Trees
• Rekursive Definition
B0 :=
Bk :=
Bk-1
Bk-1
Beispiel
Beispiel
Beispiel
Beispiel
Beispiel
Beispiel
#
1
0
4
1
6
2
4
3
1
4
„Binomial“-Baum
1
1 1
121
1331
14641
Eigenschaften eines Bino-Baums
•
•
•
•
•
1) hat 2k Knoten
2) die Höhe ist k
3) es gibt genau (ki) Knoten auf
Tiefe i = 0, 1, …, k
4) die Wurzel hat Grad k, dieser ist größer als
jeder andere in diesem Baum
weiterhin, wenn man die Kinder von links nach
rechts mit i = k-1, k-2, …, 0 numeriert,dann ist
das i-te Kind die Wurzel des Unterbaums Bi
Korrolar
• Max. Grad von einem bel. Knoten in einem
n-Knoten binom. Baum ist log(n)
– Folgt aus Eigenschaften 1-4
Binomial Heap
•
•
Definition:
Menge von Binomialbäumen mit:
1. Jeder Baum erfüllt (Min-) Heap-Eigenschaft
2. Für ein Integer k0 gibt es höchsten ein
Baum B mit deg(B)=k
1.  Die Wurzel eines Binomialbaums
enthält den kleinsten Wert.
2.  n Knoten-BinomialHeap besteht aus
höchstens logn +1 Binominalbäumen.
Beispiel |H|=13
Aufsteigender Grad
Head(H)
10
6
5
9
12
6
77
11
20
9
99
19
88
1310 = 11012
1310 = |B3|+ |B2|+ |B0|
Make-Binomial-Heap
• Trivial, in Q(1)
Make-Binomial-Heap()
head[H]=NIL;
return H;
Binomial-Heap-Minimum
BINOMIAL-HEAP-MINIMUM(H)
1 y ← NIL
2 x ← head[H]
3 min ← ∞
4 while x ≠ NIL
5 do if key[x] < min
6
then min ← key[x]
7
y←x
8
x ← sibling[x]
9 return y
• Laufzeit in O(logn)
Binomial-Heap-Union
• Hilfsfunktion Binomial-Link
BINOMIAL-LINK(y, z)
1
p[y] ← z
2
sibling[y] ← child[z]
3
child[z] ← y
4
degree[z] ← degree[z] + 1
Beispiele
• Für die 4 Fälle -> siehe Tafel
• Für einen Ablauf -> siehe Tafel
Binomial-Heap-Union
• Prinzip der binären Addition
|H1| =
23 =
10111 (B4 B2 B1 B0)
|H2| =
19 =
10011 (B4
B1 B0)
42 =
101010 (B5 B3 B1
)
Laufzeit in O(logn)
Binomial-Heap-Insert
BINOMIAL-HEAP-INSERT(H, x)
1
H′ ← MAKE-BINOMIAL-HEAP()
2
p[x] ← NIL
3
child[x] ← NIL
4
sibling[x] ← NIL
5
degree[x] ← 0
6
head[H′] ← x
7
H ← BINOMIAL-HEAP-UNION(H, H′)
Laufzeit in O(logn)
Binomial-Heap-Extract-Min
BINOMIAL-HEAP-EXTRACT-MIN(H)
1 find the root x with the minimum key in the root list of H,
and remove x from the root list of H
2 H′ ← MAKE-BINOMIAL-HEAP()
3 reverse the order of the linked list of x's children,
and set head[H′] to point to the head of the resulting list
4 H ← BINOMIAL-HEAP-UNION(H, H′)
5 return x
Laufzeit in O(logn)
Binomial-Decrease-Key
BINOMIAL-HEAP-DECREASE-KEY(H, x, k)
1 if k > key[x]
2
then error "new key is greater than current key"
3 key[x] ← k
4 y←x
5 z ← p[y]
6 while z ≠ NIL and key[y] < key[z]
7
do exchange key[y] ↔ key[z]
8
▸ If y and z have satellite fields, exchange them, too.
9
y←z
10
z ← p[y]
Zeile 6-10 wird nach Lemma 1 maximal logn mal ausgeführt
Laufzeit daher O(logn)
Binomial-Heap-Delete
BINOMIAL-HEAP-DELETE(H, x)
1 BINOMIAL-HEAP-DECREASE-KEY(H, x, -∞)
2 BINOMIAL-HEAP-EXTRACT-MIN(H)
Laufzeit O(logn)
Amortisierte Analyse: Idee
• In einer amortisierten Analyse wird die Laufzeit
für eine Sequenz von Operationen über alle
beteiligten Operationen im worst case
betrachtet, da es zu einer besseren obere
Schranke führt, da die besonders „teuren“ Fälle
besonders selten, besonders „billige“ aber recht
oft auftreten. Im Unterschied zur average case
Lauftzeitanalyse wird dabei nicht mit der
Wahrscheinlichkeit gerechnet.
Amortisierte Analyse
• Es können drei prinzipiell unterschiedliche
Methoden angewendet:
– Account-Methode
– Aggregat-Methode
– Potentialmethode
Amortisierte Analyse - Beispiel
• Betrachten Stack S neben push und
pop die Operation multipop(S,k), die
maximal k Elemente in S nacheinander
ausgibt.
MULTIPOP(S, k)
1 while not STACK-EMPTY(S) and k ≠ 0
2
do POP(S)
Amortisierte Analyse -Beispiel
Für eine Sequenz von n push, pop und
multipop Operationen auf einem anfangs
leeren Stack benötigt man im worst case:
Multipop: O(n) (der Stack könnte ja n
Elemente haben)
n Sequenzen von Operationen würde dann
n*O(n) = O(n2) bedeuten
Amortisierte Analyse
• Durch die amortisierte Laufzeitanalyse
bekommt man aber eine viel genauere
obere Schranke für Sequenzen von n
push, pop und multipop: O(n)
• Jedes gepushte Element kann nämlich nur
maximal einmal gepoppt/multipoppt
werden => max #pops(incl.Multipop) = n.
• => amortisierte kosten einer Operation ist
O(n)/n=O(1)
Potentialmethode
• Potentialfunktion: F: D->R
• Amortisierte Kosten:
• ci : wirkliche Kosten der i-ten Operation
• Di: Datenstruktur nach der i-ten Operation auf Di-1
• Für n Operationen:
Wenn F(Di)>= F(D0) für alle i,
dann findet man damit eine obere Schranke
Potentialmethode
Push, Pop, Multipop
• Potentialfunktion: F: D->N, F(Di) = Anzahl s der Elemente im Stack
• Sei i-te Operation ein Push auf einem Stack mit s Elementen
• Amortisierte Kosten für dieses Push ist
Potentialmethode
Push, Pop, Multipop
• Potentialfunktion: F: D->N, F(Di) = Anzahl s der Elemente im Stack
• Sei i-te Operation ein Multipop(S,k) auf einem Stack mit s
Elementen
F(Di) - F(Di-1) = -k‘ mit k‘=min(k,s)
• Amortisierte Kosten für dieses Multipop ist
= k‘-k‘ = 0
Die amortisierten Kosten für jede Operation ist O(1)
Fibonacci-Heaps
• Definition
– Ein Fibonacci Heap ist eine Menge von min-Heap geordneten
Bäumen, mit Wurzelknoten in einer zirkulären doppelt verketten
Liste. Einer der Wurzelknoten ist ausgezeichnet als
Minimalknoten. Alle Knoten sind markiert oder unmarkiert.
Beispiel
23
min[H]
7
3
18
52
17
38
24
26
30
39
41
35
46
Fibonacci-Heaps
Implementierung
Fibonacci-Heaps
• Die #Knoten im Fibo-Heap H wird immer
mit n(H) aufrechterhalten
• deg[x] Grad eines Knotens
• Die Bäume sind ROOTED aber
UNGEORDNET (nicht nach Grad)
Potentialfunktion Fib-Heap H
F(H) =t(H) + 2m(H)
• t(H) Anzahl der Bäume im Heap
• m(H) Anzahl der markierten Knoten im Heap
Bsp:
Bem: F(Hi)F(H0)=0
min[H]
23
7
3
17
18 52 38
39
F(H)=5 +2*3=11
41
30
24
26
35
46
Fibonacci-Heaps
• D(n) = max. Grad eines Knotens in einem
n-Knoten Fibo-Heap
Fibonacci-Heaps
• Wenn man nur die mergeable-heap
(MAKE, INSERT, MIN, EXTR-MIN,
UNION) Operationen auf ein Fibo-Heap
ausführt, dann sind alle Bäume
Ungeordnete Binomialbäume (UBB)
Ungeordnete Binomialbäume
•
•
•
•
•
Ähnlich wie Binomalbäume
U0 := O (ein Knoten)
Uk := Uk-1 wird irgendein Kind von Uk-1
Die Eigenschaften 1-3 von BB gelten,
Nur 4 => 4‘: die Wurzel hat den max. Grad
k, und die Kinder Uk-1, ..., U0 sind in
irgendeiner Reihenfolge mit der Wurzel
verbunden
• In diesem Fall D(n) = O(log n)
Make-Fib-Heap
• MAKE-FIB-HEAP()
1 n[H]=0
2 min[H]=NIL
• Laufzeit amortisiert: wegen F(H)=0 O(1)
FIB-HEAP-INSERT
• FIB-HEAP-INSERT(H, x)
1 degree[x] ← 0
2 p[x] ← NIL
3 child[x] ← NIL
4 left[x] ← x
5 right[x] ← x
6 mark[x] ← FALSE
7 concatenate the root list containing x with root list H
8 if min[H] = NIL or key[x] < key[min[H]]
9
then min[H] ← x
10 n[H] ← n[H] + 1
• Potentialänderung: ((t(H)+1)+2m(H)) – (t(H) +2m(H)) = 1
• Laufzeit amortisiert: O(1)+1=O(1)
Fib-Heap-Min
• Ganz einfach durch den Zeiger auf den
Minimal(wurzel)knoten
Fib-Heap-Union
• FIB-HEAP-UNION(H1, H2)
1
2
3
4
5
6
7
8
H ← MAKE-FIB-HEAP()
min[H] ← min[H1]
concatenate the root list of H2 with the root list of H
if (min[H1] = NIL) or (min[H2] ≠ NIL and min[H2] < min[H1])
then min[H] ← min[H2]
n[H] ← n[H1] + n[H2]
free the objects H1 and H2
return H
Fib-Heap-Extract-Min
• FIB-HEAP-EXTRACT-MIN(H)
1 z ← min[H]
2 if z ≠ NIL
3 then for each child x of z
4
do add x to the root list of H
5
p[x] ← NIL
6
remove z from the root list of H
7
if z = right[z]
8
then min[H] ← NIL
9
else min[H] ← right[z]
10
CONSOLIDATE(H)
11
n[H] ← n[H] - 1
12 return z
Fib-Heap-Extr-Min Beispiel
• Bsp siehe OH-Folie
Laufzeitanalyse
Fib-Heap-Extract-Min
• Tafel
Fib-Heap-Decrease-Key
FIB-HEAP-DECREASE-KEY(H, x, k)
1 if k > key[x]
2
then error "new key is greater than current key"
3 key[x] ← k
4 y ← p[x]
5 if y ≠ NIL and key[x] < key[y]
6
then CUT(H, x, y)
7
CASCADING-CUT(H, y)
8 if key[x] < key[min[H]]
9
then min[H] ← x
Fib-Heap-Decrease-Key
cut cascading cut
CUT(H, x, y)
1 remove x from the child list of y, decrementing degree[y]
2 add x to the root list of H
3 p[x] ← NIL
4 mark[x] ← FALSE
CASCADING-CUT(H, y)
1 z ← p[y]
2 if z ≠ NIL
3
then if mark[y] = FALSE
4
then mark[y] ← TRUE
5
else CUT(H, y, z)
6
CASCADING-CUT(H, z)
Bsp Fib-Heap-Decrease-Key
• Folie oder Tafel
Laufzeitanalyse
• Tafel
FIB-HEAP-DELETE
FIB-HEAP-DELETE(H, x)
1 FIB-HEAP-DECREASE-KEY(H, x, -∞)
2 FIB-HEAP-EXTRACT-MIN(H)
• O(1) +O(D(n)) = O(D(n))
Obere Schranke für D(n)
• Tafel