Fibonacci Heaps - PowerPoint PPT Presentation

About This Presentation
Title:

Fibonacci Heaps

Description:

Fibonacci Heaps CS 583 Analysis of Algorithms – PowerPoint PPT presentation

Number of Views:137
Avg rating:3.0/5.0
Slides: 20
Provided by: ValuedGa173
Learn more at: https://cs.gmu.edu
Category:

less

Transcript and Presenter's Notes

Title: Fibonacci Heaps


1
Fibonacci Heaps
  • CS 583
  • Analysis of Algorithms

2
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
  • Inserting a node
  • Union
  • Self-test
  • 20.2-2

3
Binomial Heaps Inserting a Node
This procedure inserts node x into binomial heap
H, assuming that x is already allocated with
keyx. Binomial-Heap-Insert(H, x) 1 H2
Make-Binomial-Heap() // create empty heap 2 px
NIL 3 childx NIL 4 siblingx NIL 5
degreex 0 6 headH2 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.
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 ltFind the root with the minimum key
in the root list of H and remove it from Hgt 2 H2
Make-Binomial-Heap() // Remove x (root) from
the tree, and // prepare the linked list as
B0, B1, ... , Bk-1 3 ltreverse the order of xs
childrengt 4 headH2 lthead of xs childrengt 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.
5
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 gt keyx 2 throw new key is
greater than the current key 3 keyx k 4 y
x 5 z p(y) // Bubble up the key in the
heap 6 while z ltgt NIL and keyy lt keyz 7
ltexchange keyy with keyzgt 8 ltexchange
satellite info y with zgt 9 y z 10 z
py 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).
6
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 xs key the smallest 1
Binomial-Heap-Decrease-Key(H, x, -?) //
Remove x from H 2 Binomial-Heap-Extract-Min(H) B
oth subroutines take O(lg n), hence the running
time of the above procedure is O(lg n).
7
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.

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
  • px pointer to its parent.
  • childx pointer to any of its children.
  • all children nodes are linked in a circular
    doubly linked list using left. and right.
    pointers.
  • degreex the number of xs children.
  • markx indicates whether the node x has lost a
    child since the last time x was made a child of
    another node.

9
Definition (cont.)
  • A Fibonacci heap H is accessed by a pointer
    minH 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
    nH.

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

11
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
The Potential Method (cont.)
  • The total amortized cost of n operations is
  • ?i1,ncai ?i1,n(ci ?(Di) - ?(Di-1))
    ?i1,nci ?(Dn) - ?(D0)
  • When ?(Dn)gt?(D0), the total amortized cost is an
    upper bound on the total actual cost.
  • Intuitively, when ?(Di)-?(Di-1) gt 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.

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 gt 0 in all
    subsequent time.
  • Hence an upper bound on total amortized cost is
    also an upper bound on total actual cost.

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.

15
Creating a New Heap
  • The Make-Fib-Heap procedure allocates and returns
    the Fibonacci heap object H, where
  • nH 0
  • minH 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).

16
Inserting a Node
This procedure inserts node x into a Fibonacci
heap assuming that x is allocated with a
keyx. Fib-Heap-Insert(H,x) // Create a
linked list containing x only 1 degreex 0 2
px NIL 3 childx NIL 4 leftx x 5
rightx x 6 markx FALSE 7 ltconcatenate
x-list with root list Hgt 8 if minH NIL or
keyx lt keyminH 9 minH x 10 nH
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)

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 minH minH1 3
ltconcatenate the root lists H2 and Hgt 4 if
(minH1 NIL) or (minH2 ltgt NIL and
keyminH2 lt keyminH1) 5 minH
minH2 6 nH nH1 nH2 7 ltfree objects
H1 and H2gt 8 return H
19
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.
Write a Comment
User Comments (0)
About PowerShow.com