Höhere Datenstrukturen

Neven SantracHeiko Ehrig

SoSe 2005 Seminar über AlgorithmenProf. Helmut Alt

Binomial HeapsFibonacci Heaps

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

Bk-1

Bk-1Bk :=

B0 :=

Beispiel

Beispiel

Beispiel

Beispiel

Beispiel

Beispiel

#

1

4

6

4

1

0

1

2

3

4

„Binomial“-Baum

1 4 6 4 11 3 3 11 2 11 11

Eigenschaften eines Bino-Baums

• 1) hat 2k Knoten• 2) die Höhe ist k• 3) es gibt genau (k

i) 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-Eigenschaft2. Für ein Integer k0 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

Head(H) 10 5

69

11

6

99912

2077

88

19

1310 = 110121310 = |B3|+ |B2|+ |B0|

Aufsteigender Grad

Make-Binomial-Heap• Trivial, in

Make-Binomial-Heap()head[H]=NIL;return H;

Binomial-Heap-MinimumBINOMIAL-HEAP-MINIMUM(H)1 y ← NIL2 x ← head[H]3 min ← ∞4 while x ≠ NIL5 do if key[x] < min6 then min ← key[x]7 y ← x8 x ← sibling[x]9 return y

• Laufzeit in logn

Binomial-Heap-Union• Hilfsfunktion Binomial-Link

BINOMIAL-LINK(y, z)1 p[y] ← z2 sibling[y] ← child[z]3 child[z] ← y4 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 logn

Binomial-Heap-InsertBINOMIAL-HEAP-INSERT(H, x)1 H′ ← MAKE-BINOMIAL-HEAP()2 p[x] ← NIL3 child[x] ← NIL4 sibling[x] ← NIL5 degree[x] ← 06 head[H′] ← x7 H ← BINOMIAL-HEAP-UNION(H, H′)

Laufzeit in logn

Binomial-Heap-Extract-MinBINOMIAL-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 list4 H ← BINOMIAL-HEAP-UNION(H, H′)5 return x

Laufzeit in logn

Binomial-Decrease-KeyBINOMIAL-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 ← z10 z ← p[y]

Zeile 6-10 wird nach Lemma 1 maximal logn mal ausgeführtLaufzeit daher logn

Binomial-Heap-Delete

BINOMIAL-HEAP-DELETE(H, x)

1 BINOMIAL-HEAP-DECREASE-KEY(H, x, -∞)2 BINOMIAL-HEAP-EXTRACT-MIN(H)

Laufzeit 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 ≠ 02 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: 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 Di)>= (D0) für alle i, dann findet man damit eine obere Schranke

Potentialmethode Push, Pop, Multipop

• Potentialfunktion: D->N, (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: D->N, (Di) = Anzahl s der Elemente im Stack

• Sei i-te Operation ein Multipop(S,k) auf einem Stack mit s Elementen

(Di) - (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

18 3852

41

23 17

30

24

35

7 3

39

26 46

min[H]

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

(H) =t(H) + 2m(H)

• t(H) Anzahl der Bäume im Heap• m(H) Anzahl der markierten Knoten im Heap

Bem: Hi)(H0)=0

Bsp:

18 3852

41

23 17

30

24

35

7 3

39

26 46

min[H]

(H)=5 +2*3=11

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]=02 min[H]=NIL

• Laufzeit amortisiert: wegen (H)=0 O(1)

FIB-HEAP-INSERT• FIB-HEAP-INSERT(H, x)1 degree[x] ← 02 p[x] ← NIL3 child[x] ← NIL4 left[x] ← x5 right[x] ← x6 mark[x] ← FALSE7 concatenate the root list containing x with root list H8 if min[H] = NIL or key[x] < key[min[H]]9 then min[H] ← x10 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 H ← MAKE-FIB-HEAP()2 min[H] ← min[H1]3 concatenate the root list of H2 with the root list of H4 if (min[H1] = NIL) or (min[H2] ≠ NIL and min[H2] < min[H1])5 then min[H] ← min[H2]6 n[H] ← n[H1] + n[H2]7 free the objects H1 and H28 return H

Fib-Heap-Extract-Min• FIB-HEAP-EXTRACT-MIN(H)1 z ← min[H]2 if z ≠ NIL3 then for each child x of z4 do add x to the root list of H5 p[x] ← NIL6 remove z from the root list of H7 if z = right[z]8 then min[H] ← NIL9 else min[H] ← right[z]10 CONSOLIDATE(H)11 n[H] ← n[H] - 112 return z

Fib-Heap-Extr-Min Beispiel

• Bsp siehe OH-Folie

Laufzeitanalyse Fib-Heap-Extract-Min

• Tafel

Fib-Heap-Decrease-KeyFIB-HEAP-DECREASE-KEY(H, x, k)

1 if k > key[x]2 then error "new key is greater than current key"3 key[x] ← k4 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 H3 p[x] ← NIL4 mark[x] ← FALSE

CASCADING-CUT(H, y)1 z ← p[y]2 if z ≠ NIL3 then if mark[y] = FALSE4 then mark[y] ← TRUE5 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