Höhere Datenstrukturen

Präsentation zum Thema: "Höhere Datenstrukturen"—  Präsentation transkript:

1 Höhere Datenstrukturen
Binomial Heaps Fibonacci Heaps Neven Santrac Heiko Ehrig SoSe 2005 Seminar über Algorithmen Prof. Helmut Alt

2 Inhalt Binomial Heap Binomial Trees Operationen
Definition, Beispiel, Eigenschaften 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

3 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

4

5 Binomial Trees Rekursive Definition B0 := Bk-1 Bk :=

6 Beispiel

7 Beispiel

8 Beispiel

9 Beispiel

10 Beispiel

11 Beispiel # 1 4 6 1 2 3 4

12 „Binomial“-Baum 1 2 1 1 1 1

13 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

14 Korrolar Max. Grad von einem bel. Knoten in einem n-Knoten binom. Baum ist log(n) Folgt aus Eigenschaften 1-4

15 Binomial Heap Definition: Menge von Binomialbäumen mit:
Jeder Baum erfüllt (Min-) Heap-Eigenschaft 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.

16 Beispiel |H|=13 1310 = |B3|+ |B2|+ |B0| 1310 = 11012
Aufsteigender Grad 6 Head(H) 10 5 12 99 6 9 9 11 77 20 19 88 1310 = 11012 1310 = |B3|+ |B2|+ |B0|

17 Make-Binomial-Heap Trivial, in Q(1) Make-Binomial-Heap() head[H]=NIL;
return H;

18 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)

19 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

20

21 Beispiele Für die 4 Fälle -> siehe Tafel
Für einen Ablauf -> siehe Tafel

22 Binomial-Heap-Union Prinzip der binären Addition
|H1| = 23 = (B4 B2 B1 B0) |H2| = 19 = (B B1 B0) 42 = (B5 B3 B ) Laufzeit in O(logn)

23 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)

24 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)

25 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)

26 Binomial-Heap-Delete
BINOMIAL-HEAP-DELETE(H, x) 1 BINOMIAL-HEAP-DECREASE-KEY(H, x, -∞) 2 BINOMIAL-HEAP-EXTRACT-MIN(H) Laufzeit O(logn)

27 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.

28 Amortisierte Analyse Es können drei prinzipiell unterschiedliche Methoden angewendet: Account-Methode Aggregat-Methode Potentialmethode

29 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)

30 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

31 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)

32 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

33 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

34 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)

35 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 min[H] 18 38 52 41 23 17 30 24 35 7 3 39 26 46

36 Fibonacci-Heaps Implementierung
Jeder Knoten hat einen Zeiger auf EINEN seiner Kinder Die Knoten auf EINER EBENE kann man mithilfe von SIBLING Zeigern traversieren

37 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)

38 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 Bem: F(Hi)³F(H0)=0 Bsp: min[H] 18 38 52 41 23 17 30 24 35 7 3 39 26 46 F(H)=5 +2*3=11

39 Fibonacci-Heaps D(n) = max. Grad eines Knotens in einem n-Knoten Fibo-Heap

40 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)

41 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)

42 Make-Fib-Heap MAKE-FIB-HEAP() 1 n[H]=0 2 min[H]=NIL
Laufzeit amortisiert: wegen F(H)=0 O(1)

43 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)

44 Fib-Heap-Min Ganz einfach durch den Zeiger auf den Minimal(wurzel)knoten

45 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 H 4 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 H2 8 return H

46 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

47

48 Fib-Heap-Extr-Min Beispiel
Bsp siehe OH-Folie

49

50 Laufzeitanalyse Fib-Heap-Extract-Min
Tafel

51 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

52 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)

53 Bsp Fib-Heap-Decrease-Key
Folie oder Tafel

54 Laufzeitanalyse Tafel

55 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))

56 Obere Schranke für D(n)
Tafel