Fibonacci Heaps & Doubled-Ended Heap Structures James Rhodes

Introduction After search trees, heaps are the second most studied type of data structure Also, called priority queues, as they keep track of a set of objects using a key value (priority) Supports the following operations: insert (insert an object), find_min (find object with minimum key), and delete_min (delete object with minimum key) Minimum or maximum can be used to create a min_heap or max_heap, respectively A double-ended heap provides both minimum and maximum operations Most important applications are event queues Examples: sweeps in computational geometry, discrete event systems, schedulers, and shortest path

Amortized Analysis Cost of operations are amortized Time to perform a sequence of operations is averaged over all operations Cost of an operation can be small when averaged over a sequence even if single operation is expensive Differs from average-case analysis because probability is not involved Guarantees the average performance of each operation in the worst case

Structure Viewed as a binary tree or an array Each node has a key and an object Parent(i) = Floor(i/2) Left(i) = 2i Right(i) = 2i + 1 Heap Order Property Heap(Parent(i)) <= Heap(i) for min_heap and Heap(Parent(i)) >= Heap(i) for max_heap Half order property no restriction for the left subtree

Fibonacci Heap The Fibonacci heap data structure serves a dual purpose It supports a set of operations that constitutes what is known as a “mergeable heap” Several Fibonacci-heap operations run in constant amortized time, which makes this data structure well suited for applications that invoke these operations frequently The oldest and best known structure that performs the decrease_key operation in constant time Each node n has an integer field n->rank, as well as a state n->state (complete or deficient)

Fibonacci Heap Defining properties: For any node n with n->rank > 1, or n->rank = 1 and n->state = complete, holds n->right = NULL, and If n->state = complete, then on the left path below n->right there are n->rank nodes, which have rank at least n->rank − 1, n->rank − 2, . . . , 0, in some sequence. If n->state = deficient, then on the left path below n->right there are n->rank − 1 nodes, which have rank at least n->rank − 2, n->rank − 3, . . . , 0, in some sequence. For any node n with n->rank = 0, or n->rank = 1 and n->state = deficient, holds n->right = NULL

Fibonacci Heap If deficient nodes are not allowed, strictly decreasing rank along the leftmost path is demanded, and the first rule is strengthened to: For any node n of with n->rank > 0, holds n->right = NULL, and on the left path below n->right, there are n->rank nodes, which have rank exactly n->rank − 1, n->rank − 2, . . . , 0, in decreasing sequence. Then that will be a binomial heap structure, thus the Fibonacci heap is a structural relaxation of the binomial heap

Fibonacci Heap Fibonacci Heap Structure: The Nodes Are Labeled by Rank and Deficiency Status

Fibonacci Heap The minimum number f (k) of nodes in a block of rank k satisfies the recursion f (k) = f (k − 2) + f (k − 3)+· · ·+f (1) + f (0) + 1 Using f (k − 1) = f (k − 3)+· · ·+f (1) + f (0) + 1, the recursion can be rewritten as f (k) = f (k − 1) + f (k − 2) This is the recurrence equation for the Fibonacci sequence which is where the structure gets its name The starting values are f (0) = f (1) = 1

If the equation is solved we get Fibonacci Heap If the equation is solved we get

Fibonacci Heap Theorem. The Fibonacci heap structure supports the operations find_min, insert, merge, delete_min, and decrease key, with find min, insert, and merge in O(1) time, decrease key in amortized O(1) time, and delete_min in amortized O(log n) time.

Operations: insert find_min merge delete_min decrease_key Fibonacci Heap Operations: insert find_min merge delete_min decrease_key

Fibonacci Heap n = number of elements in priority queue †amortized Operation Linked List Binary Heap Binomial Heap Fibonacci Heap † Relaxed Heap make-heap 1 1 1 1 1 is-empty 1 1 1 1 1 insert 1 log n log n 1 1 delete-min n log n log n log n log n decrease-key n log n log n 1 1 delete n log n log n log n log n union 1 n log n 1 1 find-min n 1 log n 1 1 n = number of elements in priority queue †amortized

Double-ended Heap A min and max heap combined Each element is inserted into both heaps Insert requires 2 operations Delete requires a delete_min or delete_max in the corresponding heap and arbitrary delete in the other Theorem. There is a double-ended heap that supports insert , find-min , find-max, merge in O(1) ; and delete-min , delete-max in O(log n) worst-case .

References Advanced Data Structures, Peter Brass, Cambridge University Press, 2008 Introduction to Algorithms, Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, Clifford Stein MIT Press, 2001 Wikipedia, Wikimedia Foundation, 2018, www.wikipedia.org, accessed 14 Feb 2019.

Questions

Thank You