Fibonacci-Heaps und deren Anwendung

Transkript

1 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 Initialisieren (Init) Einfügen eines Elementes (Insert) Zugriff auf das minimale Element (GetMin) Extrahieren des minimalen Elementes (ExtractMin) Verschmelzen von zwei (Sub-)Fibonacci-Heaps (Merge) Erhöhen der Priorität von Elementen (DecreaseKey) Löschen eines Elementes (Delete) Zusammenfassung Weitere Eigenschaften der Fibonacci-Heaps 5 6 Binomial-Queues 5 7 Vergleich mit alternativen Datenstrukturen 6 8 Anwendungen 6 1

2 1 Einleitung und Motivation Es gibt viele verschiedene Implementierungen von Prioritätswarteschlangen. Alle müssen mindestens folgende Operationen unterstützen: Einfügen eines Elementes, Auffinden des Elementes mit dem minimalen Schlüssel und Löschen dieses Elementes. Darüber hinaus werden auch oft das Löschen eines beliebigen Elementes und die Verringerung der Prioritäten verlangt. Diese ganzen Operationen werden ständig aufgerufen und sollten deshalb möglichst effizient sein. Aus der Grundstudiumsvorlesung Datenstrukturen und Algorithmen sind in der Regel einige Implementierungen von Prioritätswarteschlangen bekannt, zum Beispiel mit Hilfe von Warteschlangen oder Heaps. Die in diesem Vortrag vorgestellte Datenstruktur der Fibonacci-Heaps ist ebenfalls eine Möglichkeit der Implementierung, und zwar eine äußerst effiziente, wie im Folgenden gezeigt wird. Sie wurde 1984 von Fredman und Tarjan erstmals beschrieben. Was ist aber nun eigentlich ein Fibonacci-Heap? Diese Frage wird nachfolgend ausführlich beantwortet. Eine erste Kurzbeschreibung könnte lauten: Ein Fibonacci-Heap ist eine Datenstruktur, die aus einer Menge von heapgeordneten Bäumen besteht und die man als effiziente Prioritätsschlange einsetzen kann. Was unter der noch nicht präzisierten Bezeichnung Menge von heapgeordneten Bäumen zu verstehen ist, erfährt man im folgenden Kapitel. 2 Die Datenstruktur Ein Fibonacci-Heap ist eine Kollektion von heapgeordneten Bäumen. Diese Bäume sind allerdings anders implementiert, als man dies von gewöhnlichen Binärbäumen gewohnt ist. Heapgeordnet bedeutet, dass Nachfolgeknoten stets einen größeren Schlüsselwert haben als ihr Vaterknoten. Vom Vaterknoten zeigt ein Zeiger auf nur einen der Nachfolger. Die Nachfolger innerhalb einer Ebene sind dafür untereinander in einer zyklisch geschlossenen, doppelt verketteten Liste miteinander verknüpft. Außerdem hat jeder Knoten einen Zeiger auf seinen Vater. Darüber hinaus werden in jedem Knoten der Schlüsselwert, also die Priorität (je niedriger desto wichtiger) sowie der Rang, d.h. die Anzahl seiner Söhne, gespeichert. Letztlich benötigt jeder Knoten noch eine Boolsche Variable, die angibt, ob er markiert ist oder nicht. Die Markierung wird später für eine Operation benötigt. Das, was für jeden normalen Knoten gilt, gilt natürlich auch für die Wurzeln der einzelnen Bäume: Auch sie sind untereinander in einer zyklisch geschlossenen, doppelt verketteten Liste verknüpft. Man benötigt nun noch einen Hauptzeiger, der auf einen Startknoten zeigt. Deshalb gibt es noch einen Zeiger, der auf das minimale Element zeigt, das wegen der Heap-Eigenschaft in einer der Wurzeln zu finden ist. Abbildung 1: Beispiel eines Fibonacci-Heaps 2

3 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, erhält man durch das simple Aufsummieren der worst-case-kosten keine praxisrelevante Aussage. Um diesen Missstand zu beseitigen, ist bei der amortisierten Laufzeitanalyse also nun die Idee, dass man nicht einfach die Kosten von einer einzigen Operation betrachtet, sondern dass man sich mehrere aufeinander folgende Operationen anschaut und die Gesamtlaufzeit geschickt auf die Einzeloperationen verteilt. Dazu führt man für die Datenstruktur ein Bankkonto ein, dem sein Potenzial ( Kontostand ) bal zugeordnet wird. Einfache konstante Operationen bezahlen zusätzlich zu ihren regulären Kosten eine gewisse Anzahl von Kosteneinheiten dazu, so dass das Konto hierbei gefüllt wird, um als Reserve für komplexe Operationen herhalten zu können. Die amortisierten Kosten a i errechnen sich dann aus den tatsächlichen Kosten t i und der Veränderung des Potenzials für diese Operation: a i = t i + bal i bal i 1 4 Grundoperationen und deren Laufzeiten 4.1 Initialisieren (Init) Ein leerer Fibonacci-Heap wird erzeugt, bei dem der Pointer für das minimale Element auf NULL zeigt. 4.2 Einfügen eines Elementes (Insert) Diese Operation besteht daraus, dass das neue Element zuerst in die zyklisch verkettete Wurzelliste eingefügt wird und bei Bedarf der Pointer auf das minimale Element aktualisiert wird. Danach müssen so lange Bäume miteinander verschmolzen werden, bis keine zwei Bäume von gleichem Grad mehr vorkommen (siehe Merge-Operation). 4.3 Zugriff auf das minimale Element (GetMin) Der Zugriff auf das minimale Element erfolgt einfach über die Abfrage des entsprechenden Pointers. Dabei handelt es sich aufgrund der Heap-Eigenschaft immer um eine Wurzel. 3

4 4.4 Extrahieren des minimalen Elementes (ExtractMin) Extrahieren bedeutet hier zurückgeben und löschen. Nach dem Entfernen des Minimal-Knotens wird die Liste der Söhne des Minimalelements zunächst an die Wurzelliste angehängt. Als nächster Schritt müssen wieder zwei Bäume gleichen Ranges verbunden werden, bis nur noch Bäume mit paarweise verschiedenem Rang vorhanden sind (siehe Merge-Operation). Schließlich muss natürlich noch der Pointer für das Minimalelement auf das nun kleinste Element in der Wurzelliste gesetzt werden. Amortisierte Laufzeit: O(log n) 4.5 Verschmelzen von zwei (Sub-)Fibonacci-Heaps (Merge) Um zwei Fibonacci-Heaps miteinander zu verknüpfen, werden einfach die beiden Wurzellisten aneinander gehängt und der Minimum-Pointer auf das kleinere Minimumelement der beiden Heaps gesetzt. 4.6 Erhöhen der Priorität von Elementen (DecreaseKey) Erhöhung der Priorität eines Elementes bedeutet das Erniedrigen des Schlüsselwertes. Hierbei kann es passieren, dass die Heapordnung des Baumes zerstört wird, da unter Umständen der Schlüsselwert des Knotens kleiner als der seines Vaters wird. Wenn dies der Fall ist, wird der Knoten nach Herabsetzen des Schlüssels von seinem Vater abgetrennt und zusammen mit allen seinen Nachkommen in die Wurzelliste eingefügt. Der Vaterknoten - falls er keine Wurzel ist - wird nun markiert, wodurch - je nachdem ob dieser Knoten schon markiert war -, dieser wiederum auch komplett in die Wurzelliste verschoben wird. Dessen Vater muss dann wiederum markiert werden, so dass es passieren kann, dass eine ganze Reihe von Abtrennungen erfolgen muss, was man als cascading cuts bezeichnet. Amortisierte Laufzeit: O(1) 4.7 Löschen eines Elementes (Delete) Falls das Element der minimale Knoten ist, wird die ExtractMin-Operation durchgeführt und man ist fertig. Ist dies nicht der Fall, wird es mitsamt seiner eventuellen Nachfolger in die Wurzelliste eingehangen. Hierbei muss der eventuelle Vater markiert werden, was weitere cascading cuts nach sich ziehen kann. Schließlich wird noch das eigentlich zu löschende Element aus der Wurzelliste entfernt und seine Söhne der Wurzelliste hinzugefügt. Amortisierte Laufzeit: O(log n) 4.8 Zusammenfassung Hier eine Übersicht über die Laufzeiten: Operationen worst case amortisiert Insert 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 5 Weitere Eigenschaften der Fibonacci-Heaps Es bleiben ein paar Fragen: Warum heißt diese Datenstruktur Fibonacci-Heap? Kann man eine Aussage darüber treffen, ob und wie der maximale Grad eines Fibonacci-Heaps beschränkt ist? Dazu betrachte die folgenden Aussagen. (5.1) Lemma Sei S k die minimale Anzahl von Knoten in einem Teilbaum, dessen Wurzel Grad i hat. Dann gilt: S 0 = 1, S 1 2 und S i 2 + S 0 + S S i 2 für i 2. (5.2) Lemma Sei F i die i-te Fibonacci-Zahl, also 0 falls i = 0 F i = 1 falls i = 1 F i 1 + F i 2 falls 1 2 (Die Folge der Fibonacci-Zahlen lautet: 0,1,1,2,3,5,8,...) Dann gilt: Für i 0 ist S i F i+2. Das ist der Grund, warum die Fibonacci-Heaps ihren Namen haben. (5.3) Satz Für den maximalen Grad d max eines Knotens in einem Fibonacci-Heap gilt: wobei d max log Φ n + O(1), Φ = , 61 2 der Goldene Schnitt ist (bzw. dessen Kehrwert). Der maximale Grad eines Fibonacci-Heaps ist also logarithmisch beschränkt. 6 Binomial-Queues Fibonacci-Heaps sind eng verwandt mit Binomial-Bäumen und Binomial-Queues und verhalten sich ähnlich. Sie strukturieren sich unter bestimmten Umständen (wenn nur bestimmte Operationen genutzt werden) von selbst zu Binomialbäumen, ohne dass dies explizit gefordert ist. Eine Binomial-Queue besteht aus einer Ansammlung von Binomialbäumen und ist ebenfalls eine recht effiziente Form einer Prioritätswarteschlange, lediglich das Verringern der Prioritäten erfordert eine höhere Laufzeit. So gesehen könnte man Fibonacci-Heaps auch als Verbesserung oder Erweiterung von Binomial- Queues bezeichnen, auch wenn die Definitionen nicht direkt aufeinander aufbauen. Deshalb hier ein kleiner Exkurs in diese verwandte Datenstruktur. Ein Binomialbaum ist induktiv definiert, wie aus Abbildung 2 ersichtlich ist. (6.1) Lemma B i hat 2 i Knoten. Die Anzahl der Knoten in Tiefe t ist ( i t). Insbesondere hat die Wurzel von B i Grad i, und kein anderer Knoten hat einen so hohen Grad. (6.2) Definition Eine Menge von heap-geordneten Binomialbäumen, von denen keine zwei den gleichen Grad haben, heißt Binomial-Queue. (6.3) Beispiel Eine Binomial-Queue, die aus B 0, B 1 und B 2 besteht, kann also = = 7 Elemente aufnehmen. 5

6 Abbildung 2: Induktive Definition eines Binomialbaumes Eine Binomial-Queue unterstützt natürlich als Prioritätswarteschlange genau wie ein Fibonacci-Heap alle dazu notwendigen Operationen. Um diese zu implementieren, benötigt man auch das Verschmelzen von zwei Binomial-Queues. Auf die Laufzeiten der Binomial-Queues wird im Vortrag auch beim Vergleich der Datenstrukturen (Kapitel 7) eingegangen. Fibonacci-Heaps sind den Binomial-Queues nicht nur ähnlich, sondern es gilt insbesondere auch folgendes: Wenn man auf einen anfangs leeren Fibonacci-Heap nur die (im Folgenden noch näher erläuterten) Operationen Insert, FindMin, Merge und ExtractMin anwendet, so haben die einzelnen Bäume aus der Wurzelliste des Fibonacci-Heaps immer die Struktur von Binomial-Bäume. Und am Ende einer DeleteMin-Operation bildet der gesamte Fibonacci-Heap sogar eine Binomial-Queue. 7 Vergleich mit alternativen Datenstrukturen Nachdem nun die Laufzeiten analysiert sind, ist natürlich interessant, diese mit denen anderer Implementierungen von Prioritätswarteschlangen zu vergleichen. Insert GetMin ExtractMin DecreaseKey Delete unsortierte Liste O(1) O(n) O(n) O(n) O(n) sortierte Liste O(n) O(1) O(1) O(n) O(n) binärer Suchbaum O(log n) O(log n) O(log n) O(log n) O(log n) binärer 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 herkömmlicher worst case) 8 Anwendungen Im Vortrag werden mit dem Dijkstra- und dem Prim-Algorithmus zwei Beispiel-Algorithmen betrachtet, in denen Fibonacci-Heaps als effiziente Prioritätswarteschlangen eingesetzt werden können. Beim Dijkstra- Algorthmus erreicht man dadurch eine Laufzeit in O( E + V log V ), der Prim-Algorithmus verbessert sich auf O( V log V + E ) 6

7 Literatur [Corm] Cormen, Leierson, Rivest, Stein: Introduction to Algorithms. MIT Press 2001 [Ottm] [Web1] Ottmann, Wittmayer: Algorithmen und Datenstrukturen, 3. Auflage, Spektrum Lehrbuch [Web2a] ws9899 html [Web2b] ws9898 chap1.ps [Web2c] [Web3] [Web4] [Web5] [Web6] [Web7] krumke/teaching/ss2004/proseminar/data/fibonacci.pdf tick/pages/lehre/ea1/heapsd.pdf da98/skript.ps.gz heap 7