Download presentation
Presentation is loading. Please wait.
1
CS 583 Analysis of Algorithms
Fibonacci Heaps CS 583 Analysis of Algorithms 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
2
CS583 Fall'06: Binomial and Fibonacci Heaps
Outline Operations on Binomial Heaps Inserting a node Extracting the node with minimum key Decreasing a key Deleting a key Fibonacci Heaps Definitions Amortized analysis Union Self-test 20.2-2 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
3
Binomial Heaps: Inserting a Node
This procedure inserts node x into binomial heap H, assuming that x is already allocated with key[x]. Binomial-Heap-Insert(H, x) 1 H2 = Make-Binomial-Heap() // create empty heap 2 p[x] = NIL 3 child[x] = NIL 4 sibling[x] = NIL 5 degree[x] = 0 6 head[H2] = x 7 H = Binomial-Heap-Union(H, H2) The procedure makes a one node heap H2 in (1) time and unites it with the n-node binomial heap H in O(lg n) time. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
4
Extracting Minimum Node
This procedure extracts the node with the minimum key from heap H and returns a pointer to the extracted node. Binomial-Heap-Extract-Min(H) 1 x = <Find the root with the minimum key in the root list of H and remove it from H> 2 H2 = Make-Binomial-Heap() // Remove x (root) from the tree, and // prepare the linked list as B0, B1, ... , Bk-1 3 <reverse the order of x’s children> 4 head[H2] = <head of x’s children> 5 H = Binomial-Heap-Union(H,H2) 6 return x Each of lines 1,3,4,5 takes O(lg n) time if H has n nodes. Hence the above procedure runs in O(lg n) time. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
5
CS583 Fall'06: Binomial and Fibonacci Heaps
Decreasing a Key This procedure decreases the key of a node x in a heap H to a new value k. Binomial-Heap-Decrease(H, x, k) 1 if k > key[x] 2 throw “new key is greater than the current key” 3 key[x] = k 4 y = x 5 z = p(y) // Bubble up the key in the heap 6 while z <> NIL and key[y] < key[z] 7 <exchange key[y] with key[z]> 8 <exchange satellite info y with z> 9 y = z 10 z = p[y] The maximum depth of x is lg n, hence the while loop 6 iterates at most lg n times. Each iteration takes (1) time, hence the running time of the algorithm is O(lg n). 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
6
CS583 Fall'06: Binomial and Fibonacci Heaps
Deleting a Key Deleting a key is a straightforward combination of existing procedures. The procedure takes a heap H, and the node x. Binomial-Heap-Delete(H, x) // Make x’s key the smallest 1 Binomial-Heap-Decrease-Key(H, x, -) // Remove x from H 2 Binomial-Heap-Extract-Min(H) Both subroutines take O(lg n), hence the running time of the above procedure is O(lg n). 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
7
CS583 Fall'06: Binomial and Fibonacci Heaps
Fibonacci heaps support meargeable-heap operations: Insert, Minimum, Extract-Min, Union, Decrease-Key, Delete. They have the advantage over other heap types in that operations that do not involve deleting an element run in (1) time. They are theoretically desirable in applications that involve small number of Extract-Min and Delete operations relative to the total number of operations. Practically, their complexity and constant factors make them less desirable than binary heaps for most applications. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
8
Fibonacci Heaps: Definition
A Fibonacci heap is a collection of min-heap trees. The trees are not constrained to be binomial trees. The trees are unordered, i.e. children nodes order does not matter. Each node x contains the following fields: p[x] pointer to its parent. child[x] pointer to any of its children. all children nodes are linked in a circular doubly linked list using left[.] and right[.] pointers. degree[x] – the number of x’s children. mark[x] indicates whether the node x has lost a child since the last time x was made a child of another node. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
9
CS583 Fall'06: Binomial and Fibonacci Heaps
Definition (cont.) A Fibonacci heap H is accessed by a pointer min[H] to the root of a tree containing a minimum key. This node is called the minimum node. The roots of all trees in the Fibonacci heap H are linked together into a circular doubly linked list. The list is called the root list of H. Roots are linked using left and right pointers. The order of trees within a root list is arbitrary. The number of nodes currently in H is kept in n[H]. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
10
CS583 Fall'06: Binomial and Fibonacci Heaps
Amortized Analysis In amortized analysis, the time required to perform a sequence of data-structure operations is averaged over all operations performed. It differs from the average-case analysis in that probability is not involved. It guarantees the average performance of each operation in the worst case. The potential method of amortized analysis represents the prepaid work as “potential” that can be released for future operations. The total “work” on a data structure is spread unevenly over the course of an algorithm. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
11
CS583 Fall'06: Binomial and Fibonacci Heaps
The Potential Method Start with an initial data structure D0 on which n operations are performed. Let ci, i= 1,...,n be the actual cost of the ith operation. Di is the data structure that results after applying the ith operation on Di-1. A potential function maps each data structure Di to a real number (Di), which is a potential associated with Di. The amortized cost cai of the ith operation is: cai = ci + (Di) - (Di-1) It is thus an actual cost of operation plus the increase in potential due to the operation. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
12
The Potential Method (cont.)
The total amortized cost of n operations is: i=1,ncai = i=1,n(ci + (Di) - (Di-1)) = i=1,nci + (Dn) - (D0) When (Dn)>(D0), the total amortized cost is an upper bound on the total actual cost. Intuitively, when (Di)-(Di-1) > 0, the amortized cost of the ith operation represents an overcharge. Otherwise, the amortized cost represents an undercharge, and the actual cost is paid by decrease in potential. Different potential functions may yield different amortized costs, but still be upper bound on the actual costs. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
13
Fibonacci Heap: Potential Function
For a given Fibonacci heap H, we denote: t(H) – the number of trees in the root list. m(H) – the number of marked nodes in H. The potential of Fibonacci heap H is defined as: (H) = t(H) + 2 m(H) Assume that a Fibonacci heap application begins with no heaps. The initial potential is 0. By above equation, the potential >= 0 in all subsequent time. Hence an upper bound on total amortized cost is also an upper bound on total actual cost. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
14
Mergeable-Heap Operations
For basic mergeable-heap operations (Make-Heap, Insert, Minimum, Extract-Min, Union): Each Fibonacci heap is a collection of “unordered” binomial trees. An unordered binomial tree is like a binomial tree, and is defined recursively. The tree U0 contains a single node. The tree Uk consists of two unordered binomial trees Uk-1 for which the root of one is made into any child of the root of another. The following property is different from the ordered binomial trees. For the tree Uk, the root has degree k, which is greater than of any other node. The children of the root are U0,U1,....Uk-1 in some order. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
15
CS583 Fall'06: Binomial and Fibonacci Heaps
Creating a New Heap The Make-Fib-Heap procedure allocates and returns the Fibonacci heap object H, where: n[H] = 0 min[H] = NIL there are no trees in H. The potential is determined by t(H) = 0 and m(H) = 0: (H) = 0 Hence the amortized cost is the same as actual cost, -- (1). 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
16
CS583 Fall'06: Binomial and Fibonacci Heaps
Inserting a Node This procedure inserts node x into a Fibonacci heap assuming that x is allocated with a key[x]. Fib-Heap-Insert(H,x) // Create a linked list containing x only 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 x-list with root list H> 8 if min[H] = NIL or key[x] < key[min[H]] 9 min[H] = x 10 n[H]++ 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
17
Inserting Node: Performance
Let H be the input heap, and H2 be the resulting heap. Then t(H2) = t(H) + 1 m(H2) = m(H) The increase in potential is: ((t(H)+1) + 2 m(H)) – (t(H) + 2 m(H)) = 1 The amortized cost is Actual cost + 1 = (1) + 1 = (1) 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
18
Uniting Two Fibonacci Heaps
This procedure unites heaps H1 and H2, destroying them in the process. It simply concatenates root lists and determines the new minimum node. Fib-Heap-Union(H1,H2) 1 H = Make-Fib-Heap() 2 min[H] = min[H1] 3 <concatenate the root lists H2 and H> 4 if (min[H1] = NIL) or (min[H2] <> NIL and key[min[H2]] < key[min[H1]]) 5 min[H] = min[H2] 6 n[H] = n[H1] + n[H2] 7 <free objects H1 and H2> 8 return H 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
19
CS583 Fall'06: Binomial and Fibonacci Heaps
Union: Performance The components of potential are: t(H) = t(H1) + t(H2) m(H) = m(H1) + m(H2) The change in potential is: (H) – ((H1) + (H2)) = 0 The amortized cost is therefore equal to the actual cost. The actual cost is (1) = amortized cost. 12/27/2018 CS583 Fall'06: Binomial and Fibonacci Heaps
Similar presentations
