Fibonacci-Heaps und deren Anwendung

Alexander Schiffel und Stefan Hurtz

24. Juli 2005

Inhaltsverzeichnis

1 Einleitung und Motivation 2

2 Die Datenstruktur 2

3 Amortisierte Laufzeitanalyse 3

4 Grundoperationen und deren Laufzeiten 34.1 Initialisieren (Init) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34.2 Einfugen eines Elementes (Insert) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34.3 Zugriff auf das minimale Element (GetMin) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34.4 Extrahieren des minimalen Elementes (ExtractMin) . . . . . . . . . . . . . . . . . . . . . . . . 44.5 Verschmelzen von zwei (Sub-)Fibonacci-Heaps (Merge) . . . . . . . . . . . . . . . . . . . . . . 44.6 Erhohen der Prioritat von Elementen (DecreaseKey) . . . . . . . . . . . . . . . . . . . . . . . 44.7 Loschen eines Elementes (Delete) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44.8 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

5 Weitere Eigenschaften der Fibonacci-Heaps 5

6 Binomial-Queues 5

7 Vergleich mit alternativen Datenstrukturen 6

8 Anwendungen 6

1

1 Einleitung und Motivation

Es gibt viele verschiedene Implementierungen von Prioritatswarteschlangen. Alle mussen mindestens fol-gende Operationen unterstutzen: Einfugen eines Elementes, Auffinden des Elementes mit dem minimalenSchlussel und Loschen dieses Elementes. Daruber hinaus werden auch oft das Loschen eines beliebigen Ele-mentes und die Verringerung der Prioritaten verlangt. Diese ganzen Operationen werden standig aufgerufenund sollten deshalb moglichst effizient sein. Aus der Grundstudiumsvorlesung ”Datenstrukturen und Algo-rithmen“ sind in der Regel einige Implementierungen von Prioritatswarteschlangen bekannt, zum Beispiel mitHilfe von Warteschlangen oder Heaps. Die in diesem Vortrag vorgestellte Datenstruktur der Fibonacci-Heapsist ebenfalls eine Moglichkeit der Implementierung, und zwar eine außerst effiziente, wie im Folgenden gezeigtwird. Sie wurde 1984 von Fredman und Tarjan erstmals beschrieben.

Was ist aber nun eigentlich ein Fibonacci-Heap? Diese Frage wird nachfolgend ausfuhrlich beantwortet.Eine erste Kurzbeschreibung konnte lauten:Ein Fibonacci-Heap ist eine Datenstruktur, die aus einer ”Menge von heapgeordneten Baumen“ besteht unddie man als effiziente Prioritatsschlange einsetzen kann.Was unter der noch nicht prazisierten Bezeichnung ”Menge von heapgeordneten Baumen“ zu verstehen ist,erfahrt man im folgenden Kapitel.

2 Die Datenstruktur

Ein Fibonacci-Heap ist eine Kollektion von heapgeordneten Baumen. Diese Baume sind allerdings an-ders implementiert, als man dies von gewohnlichen Binarbaumen gewohnt ist. Heapgeordnet bedeutet, dassNachfolgeknoten stets einen großeren Schlusselwert haben als ihr Vaterknoten. Vom Vaterknoten zeigt einZeiger auf nur einen der Nachfolger. Die Nachfolger innerhalb einer Ebene sind dafur untereinander in einerzyklisch geschlossenen, doppelt verketteten Liste miteinander verknupft. Außerdem hat jeder Knoten einenZeiger auf seinen Vater. Daruber hinaus werden in jedem Knoten der Schlusselwert, also die Prioritat (jeniedriger desto wichtiger) sowie der Rang, d.h. die Anzahl seiner Sohne, gespeichert. Letztlich benotigt jederKnoten noch eine Boolsche Variable, die angibt, ob er markiert ist oder nicht. Die Markierung wird spaterfur eine Operation benotigt. Das, was fur jeden normalen Knoten gilt, gilt naturlich auch fur die Wurzelnder einzelnen Baume: Auch sie sind untereinander in einer zyklisch geschlossenen, doppelt verketteten Listeverknupft. Man benotigt nun noch einen Hauptzeiger, der auf einen Startknoten zeigt. Deshalb gibt es nocheinen Zeiger, der auf das minimale Element zeigt, das wegen der Heap-Eigenschaft in einer der Wurzeln zufinden ist.

Abbildung 1: Beispiel eines Fibonacci-Heaps

2

Ein Knoten eines Fibonacci-Heaps ist also durch folgende Typvereinbarung charakterisiert:

type heap_ordered_tree = ^.node;node = record

left, right: ^.node;father, son: ^.node;key: integer;rank: integer;marker: boolean;end;

3 Amortisierte Laufzeitanalyse

Wenn man die Gesamtkosten einer Abfolge von Operationen berechnen will, erhalt man durch das simpleAufsummieren der worst-case-Kosten keine praxisrelevante Aussage.Um diesen Missstand zu beseitigen, ist bei der amortisierten Laufzeitanalyse also nun die Idee, dass mannicht einfach die Kosten von einer einzigen Operation betrachtet, sondern dass man sich mehrere aufeinanderfolgende Operationen anschaut und die Gesamtlaufzeit geschickt auf die Einzeloperationen verteilt.Dazu fuhrt man fur die Datenstruktur ein ”Bankkonto“ ein, dem sein Potenzial (”Kontostand“) bal zugeordnetwird.

”Einfache“ konstante Operationen bezahlen zusatzlich zu ihren regularen Kosten eine gewisse Anzahl vonKosteneinheiten dazu, so dass das ”Konto“ hierbei gefullt wird, um als Reserve fur komplexe Operationenherhalten zu konnen.Die amortisierten Kosten ai errechnen sich dann aus den tatsachlichen Kosten ti und der Veranderung desPotenzials fur diese Operation:

ai = ti + bali − bali−1

4 Grundoperationen und deren Laufzeiten

4.1 Initialisieren (Init)

Ein leerer Fibonacci-Heap wird erzeugt, bei dem der Pointer fur das minimale Element auf NULL zeigt.

(Amortisierte) Laufzeit: O(1)

4.2 Einfugen eines Elementes (Insert)

Diese Operation besteht daraus, dass das neue Element zuerst in die zyklisch verkettete Wurzelliste ein-gefugt wird und bei Bedarf der Pointer auf das minimale Element aktualisiert wird.Danach mussen so lange Baume miteinander verschmolzen werden, bis keine zwei Baume von gleichem Gradmehr vorkommen (siehe Merge-Operation).

(Amortisierte) Laufzeit: O(1)

4.3 Zugriff auf das minimale Element (GetMin)

Der Zugriff auf das minimale Element erfolgt einfach uber die Abfrage des entsprechenden Pointers. Dabeihandelt es sich aufgrund der Heap-Eigenschaft immer um eine Wurzel.

(Amortisierte) Laufzeit: O(1)

3

4.4 Extrahieren des minimalen Elementes (ExtractMin)

Extrahieren bedeutet hier zuruckgeben und loschen. Nach dem Entfernen des Minimal-Knotens wird dieListe der Sohne des Minimalelements zunachst an die Wurzelliste angehangt. Als nachster Schritt mussenwieder zwei Baume gleichen Ranges verbunden werden, bis nur noch Baume mit paarweise verschiedenemRang vorhanden sind (siehe Merge-Operation).Schließlich muss naturlich noch der Pointer fur das Minimalelement auf das nun kleinste Element in derWurzelliste gesetzt werden.

Amortisierte Laufzeit: O(log n)

4.5 Verschmelzen von zwei (Sub-)Fibonacci-Heaps (Merge)

Um zwei Fibonacci-Heaps miteinander zu verknupfen, werden einfach die beiden Wurzellisten aneinandergehangt und der Minimum-Pointer auf das kleinere Minimumelement der beiden Heaps gesetzt.

(Amortisierte) Laufzeit: O(1)

4.6 Erhohen der Prioritat von Elementen (DecreaseKey)

Erhohung der Prioritat eines Elementes bedeutet das Erniedrigen des Schlusselwertes. Hierbei kann es pas-sieren, dass die Heapordnung des Baumes zerstort wird, da unter Umstanden der Schlusselwert des Knotenskleiner als der seines Vaters wird.Wenn dies der Fall ist, wird der Knoten nach Herabsetzen des Schlussels von seinem Vater abgetrennt undzusammen mit allen seinen Nachkommen in die Wurzelliste eingefugt.Der Vaterknoten - falls er keine Wurzel ist - wird nun markiert, wodurch - je nachdem ob dieser Knotenschon markiert war -, dieser wiederum auch komplett in die Wurzelliste verschoben wird. Dessen Vater mussdann wiederum markiert werden, so dass es passieren kann, dass eine ganze Reihe von Abtrennungen erfolgenmuss, was man als cascading cuts bezeichnet.

Amortisierte Laufzeit: O(1)

4.7 Loschen eines Elementes (Delete)

Falls das Element der minimale Knoten ist, wird die ExtractMin-Operation durchgefuhrt und man ist fer-tig.Ist dies nicht der Fall, wird es mitsamt seiner eventuellen Nachfolger in die Wurzelliste eingehangen. Hierbeimuss der eventuelle Vater markiert werden, was weitere cascading cuts nach sich ziehen kann.Schließlich wird noch das eigentlich zu loschende Element aus der Wurzelliste entfernt und seine Sohne derWurzelliste hinzugefugt.

Amortisierte Laufzeit: O(log n)

4.8 Zusammenfassung

Hier eine Ubersicht uber die Laufzeiten:

Operationen worst case amortisiertInsert O(1) O(1)Merge O(1) O(1)GetMin O(1) O(1)ExtractMin O(n) O(log n)DecreaseKey O(log n) O(1)Delete O(log n) O(log n)

4

5 Weitere Eigenschaften der Fibonacci-Heaps

Es bleiben ein paar Fragen: Warum heißt diese Datenstruktur Fibonacci-Heap? Kann man eine Aussagedaruber treffen, ob und wie der maximale Grad eines Fibonacci-Heaps beschrankt ist? Dazu betrachte diefolgenden Aussagen.

(5.1) Lemma Sei Sk die minimale Anzahl von Knoten in einem Teilbaum, dessen Wurzel Grad i hat. Danngilt:

S0 = 1,

S1 ≥ 2 und

Si ≥ 2 + S0 + S1 + ... + Si−2 fur i ≥ 2.

(5.2) Lemma Sei Fi die i-te Fibonacci-Zahl, also

Fi =

0 falls i = 01 falls i = 1

Fi−1 + Fi−2 falls 1 ≥ 2

(Die Folge der Fibonacci-Zahlen lautet: 0,1,1,2,3,5,8,...)Dann gilt: Fur i ≥ 0 ist Si ≥ Fi+2.Das ist der Grund, warum die Fibonacci-Heaps ihren Namen haben.

(5.3) Satz Fur den maximalen Grad dmax eines Knotens in einem Fibonacci-Heap gilt:

dmax ≤ logΦ n + O(1),

wobei

Φ =1 +

√5

2≈ 1, 61

der ”Goldene Schnitt“ ist (bzw. dessen Kehrwert).Der maximale Grad eines Fibonacci-Heaps ist also logarithmisch beschrankt.

6 Binomial-Queues

Fibonacci-Heaps sind eng verwandt mit Binomial-Baumen und Binomial-Queues und verhalten sich ahn-lich. Sie strukturieren sich unter bestimmten Umstanden (wenn nur bestimmte Operationen genutzt werden)von selbst zu Binomialbaumen, ohne dass dies explizit gefordert ist.Eine Binomial-Queue besteht aus einer Ansammlung von Binomialbaumen und ist ebenfalls eine rechteffiziente Form einer Prioritatswarteschlange, lediglich das Verringern der Prioritaten erfordert eine hohereLaufzeit. So gesehen konnte man Fibonacci-Heaps auch als Verbesserung oder Erweiterung von Binomial-Queues bezeichnen, auch wenn die Definitionen nicht direkt aufeinander aufbauen. Deshalb hier ein kleinerExkurs in diese verwandte Datenstruktur.Ein Binomialbaum ist induktiv definiert, wie aus Abbildung 2 ersichtlich ist.

(6.1) Lemma Bi hat 2i Knoten. Die Anzahl der Knoten in Tiefe t ist(

it

). Insbesondere hat die Wurzel

von Bi Grad i, und kein anderer Knoten hat einen so hohen Grad.

(6.2) Definition Eine Menge von heap-geordneten Binomialbaumen, von denen keine zwei den gleichenGrad haben, heißt Binomial-Queue.

(6.3) Beispiel Eine Binomial-Queue, die aus B0, B1 und B2 besteht, kann also 20 +21 +22 = 1+2+4 = 7Elemente aufnehmen.

5

Abbildung 2: Induktive Definition eines Binomialbaumes

Eine Binomial-Queue unterstutzt naturlich als Prioritatswarteschlange genau wie ein Fibonacci-Heap alledazu notwendigen Operationen. Um diese zu implementieren, benotigt man auch das Verschmelzen von zweiBinomial-Queues.Auf die Laufzeiten der Binomial-Queues wird im Vortrag auch beim Vergleich der Datenstrukturen (Kapitel7) eingegangen.

Fibonacci-Heaps sind den Binomial-Queues nicht nur ahnlich, sondern es gilt insbesondere auch folgendes:Wenn man auf einen anfangs leeren Fibonacci-Heap nur die (im Folgenden noch naher erlauterten) Operatio-nen Insert, FindMin, Merge und ExtractMin anwendet, so haben die einzelnen Baume aus der Wurzelliste desFibonacci-Heaps immer die Struktur von Binomial-Baume. Und am Ende einer DeleteMin-Operation bildetder gesamte Fibonacci-Heap sogar eine Binomial-Queue.

7 Vergleich mit alternativen Datenstrukturen

Nachdem nun die Laufzeiten analysiert sind, ist naturlich interessant, diese mit denen anderer Implementie-rungen von Prioritatswarteschlangen zu vergleichen.

Insert GetMin ExtractMin DecreaseKey Deleteunsortierte Liste O(1) O(n) O(n) O(n) O(n)sortierte Liste O(n) O(1) O(1) O(n) O(n)binarer Suchbaum O(log n) O(log n) O(log n) O(log n) O(log n)binarer Heap O(log n) O(1) O(log n) O(log n) O(log n)Binomial-Queue* O(1) O(log n) O(log n) O(log n) O(log n)Fibonacci-Heap* O(1) O(1) O(log n) O(1) O(log n)

*zum Teil amortisiert (sonst ”herkommlicher“ worst case)

8 Anwendungen

Im Vortrag werden mit dem Dijkstra- und dem Prim-Algorithmus zwei Beispiel-Algorithmen betrachtet,in denen Fibonacci-Heaps als effiziente Prioritatswarteschlangen eingesetzt werden konnen. Beim Dijkstra-Algorthmus erreicht man dadurch eine Laufzeit in O(|E|+ |V | log |V |), der Prim-Algorithmus verbessert sichauf O(|V | log |V |+ |E|)

6

Literatur

[Corm] Cormen, Leierson, Rivest, Stein: Introduction to Algorithms. MIT Press 2001

[Ottm] Ottmann, Wittmayer: Algorithmen und Datenstrukturen, 3. Auflage, Spektrum Lehrbuch

[Web1] http://infos.aus-germanien.de/Fibonacci-Heap

[Web2a] http://wwwmayr.informatik.tu-muenchen.de/skripten/ead ws9899 html

[Web2b] http://wwwmayr.informatik.tu-muenchen.de/skripten/ead ws9898 chap1.ps

[Web2c] http://wwwmayr.informatik.tu-muenchen.de/skripten/jensernst.ps

[Web3] http://www.mathematik.uni-kl.de/˜krumke/Teaching/SS2004/proseminar/Data/fibonacci.pdf

[Web4] http://www.mathematik.uni-marburg.de/˜tick/Pages/Lehre/EA1/heapsd.pdf

[Web5] http://www.mpi-sb.mpg.de/˜da98/skript.ps.gz

[Web6] http://ad.informatik.uni-freiburg.de/bibiothek/diplom/lauer.pdf

[Web7] http://en.wikipedia.org/wiki/Fibonacci heap

7