Four different data structures, each one best in a different setting. Simple Heap Balanced Heap Fibonacci Heap Incremental Heap Our results

A balanced binary tree, with items in the leaves in left-right order by decreasing key slope. The tree is a tournament on items by current key. Simple heap (highlights) We get O(log 2 n) for delete and insert O(1) for find-min All bounds are amortized

A better deletions only data structure Dynamize using the technique of Bently and Saxe Balanced heap (highlights) We get O(log n loglog n) for delete O(log n) for find-min and insert

Based one Fibonacci heaps with lazy linking. We link only when it is safe Fibonacci heap (highlights) We get O(log 2 n) for delete O(log n) for find-min and insert O(log n) for decrease-key

Incremental heap (highlights) Assumptions insertion of i: a i = 1, increase key of i: a i := a i + 1 Group items by key slope, each group is an ordinary Fibonacci heap Move items among groups as key slopes change (“displaced” items because entire subtrees are moved) We get find-max, insert : O(1) The k th increase-key : O(log min{k,n}) delete : O(log n)

A balanced binary tree, with items in the leaves in left-right order by decreasing key slope. The tree is a tournament on items by current key. Simple heap (details)

a b e d c a b d c e a a c a       

Simple kinetic heaps (Cont) Add swap times at internal nodes

a b e d c a b d c e a a c a       

Simple kinetic heaps (Cont) Add minimum future swap time

a b e d c a b d c e a a c a       

Simple kinetic heaps (Cont) When we do a find-min if the current time moves forward, we act as follows: Locate all nodes whose winner changes. The paths from the root to those nodes form a subtree. Update this subtree

a b e d c a b d c e a a c a       

a b e d c a b d c e a a c a       

a b e d c a b d c e b a c a               

a b e d c a b d c e b b  20 3        c a

a b e d c a b d c e b b  20 3        c b

a b e d c a b d c e b b c b         6.8

a b e d c a b d c e b b c b        

a b e d c a b d c e b b e e         20 3 

a b e d c a b d c e b b e e         3 

Simple kinetic heaps – insert & delete Use the regular mechanism of (say) red-black trees

a b e d c a b d c e b b e e f         

a b e d c a b d c e b b e e   f f f  -20       

a b e d c a b d c e b f e e     f f f  -20       

Simple kinetic heaps (analysis) Find-min takes O(1) time if we do not advance the current time. Advancing the current time can be expensive on the worst-case Amortization: Assign O(log n) potential to each node whose swap time is in the future. This potential pays for advancing the time. So find-min takes O(1) amortized time. Insert and delete take O(log 2 n) amortized time

How do we make this a parametric heap ? (Overmars-Van Leeuwen)

a b e d c a b c e        d

Looks like we use non linear space ? Each node keeps the chain of segments that are on its envelope but not on its parent envelope. This makes the space linear.

a b e d c a b c e        d

Analysis Using search trees to represent the envelopes sorted by slopes then: Find-min takes O(log n) time Insert and delete take O(log 2 n) time: You split and concatenate O(log n) such envelopes.

Balanced kinetic heaps Def: The level of a line is the depth of the highest node where it is stored. Plan: first we’ll do only deletions faster and then we’ll add insertions. Our starting point is the previous data structure.

Deletion-only data structure The level of a line is the depth of the highest node where it is stored.

a b e d c a b c e        d d

Deletion-only data structure What happens when we delete a line ?

a b e d c a b c e        d d

a b e d c a b e        d d

a b e d c a b e        d d

a b e d c a b e        d d

Balanced kinetic heaps When we delete a line, lines only decrease their level.

      

      

Analysis Key idea: Implement the envelopes using finger search trees How much time it takes to delete an element ? O(log n) +  log (# lines get on the replacement piece) +  log (# lines get off the replacement piece) If in all nodes # lines get on/off the replacement piece < log 2 n we are ok --- the delete takes O(log n loglog n) time However it could be that # lines get on/off the replacement piece > log 2 n

Analysis (Cont) If a line gets on the replacement piece it changes its level Since the total number of level changes is nlog(n) The number of chains of length > log 2 n is at most n/log(n) So the total work in moving long chain is O(n) and can be charged to the initialization phase.

A better deletions only data structure O(n) init. time and then O(log n loglog n) per delete. O(1) find-min if we are kinetic. Now we add insert. Summary so far

Balanced kinetic heaps (finalle) Balanced heaps (step 2): Use a well known reduction by Bently and Saxe to add insertions Maintain a binary counter of deletion only data structures

Balanced kinetic heaps Delete : O(log n loglog n) Insert : O(log n) Find-min : O(log n) (kinetic)

Based one Fibonacci heaps with lazy linking. We link only when it is safe Fibonacci heap (highlights) We get O(log 2 n) for delete O(log n) for find-min and insert O(log n) for decrease-key

Fibonacci Kinetic Heap Mimic Fibonacci heap, but only do links for permanent comparisons. Store unlinked tree roots of equal rank in a sorted list O(log n) find min, insert, decrease key, O(log 2 n) delete, amortized

Fibonacci heaps (Fredman & Tarjan 84) Want to do decrease-key(x,h,  ) faster than delete+insert. ( in O(1) time.)

Heap ordered (Fibonacci) trees

Linking Operations are defined via a basic operation, called linking, of Fibonacci trees: Produce a F k from two F k-1, keep heap order

Basic idea: delay the linking until they are safe S1S1 S0S0 SrSr  Regular heap

Linking The basic operation is inserting a tree of rank r into S r, making the appropriate linking if needed. Insert(i) : Insert a new node containing i into S 0 This may cascade, but we have one tree less every time we do the linking Decrease-key(i, a’.b’) : Decrease the key of i in the tree containing it making cascading cuts, link the resulting trees back into the structure.

Analysis Similar to the analysis of F-heaps Multiply the potential by log n

Incremental heap (highlights) Assumptions insertion of i: a i = 1, increase key of i: a i := a i + 1 Group items by key slope, each group is an ordinary Fibonacci heap Move items among groups as key slopes change (“displaced” items because entire subtrees are moved) We get find-max, insert : O(1) The k th increase-key : O(log min{k,n}) delete : O(log n)

Open problems Experiments: What is the best structure in practice? Better bounds: kinetic heaps in ordinary F-heap bounds? parametric heaps in O(log n) amortized time per operation? Simple kinetic heaps via splay trees?