Post on 18-Jan-2016
A balanced binary tree, with items in the leavesin 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 ea
a c
a
Simple kinetic heaps (Cont)
Add swap times at internal nodes
a
b
e
d
c
a b
d c ea
a c
a
3
6 6.8
4.4
Simple kinetic heaps (Cont)
Add minimum future swap time
a
b
e
d
c
a b
d c ea
a c
a
3
3 6.8
3
6
3
4.4
6.8
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 ea
a c
a
3
3 6.8
3
6
3
4.4
6.8
a
b
e
d
c
a b
d c ea
a c
a
3
3 6.8
3
6
3
4.4
6.8
a
b
e
d
c
a b
d c eb
a c
a
3 6.8
3
6
3
4.4
6.8
a
b
e
d
c
a b
d c eb
b
2020
3
c
a 34.4
6.8 6.8
a
b
e
d
c
a b
d c eb
b
2020
3
c
b 55
6.8 6.8
a
b
e
d
c
a b
d c eb
b c
b
20
5
20
3
5
6.86.8
a
b
e
d
c
a b
d c eb
b c
b
20
5
20
3
5
6.86.8
a
b
e
d
c
a b
d c eb
b e
e
2020
3
6.8
205
a
b
e
d
c
a b
d c eb
b e
e
2020
3
206.3
6.8
Simple kinetic heaps – insert & delete
Use the regular mechanism of (say) red-black trees
a
b
e
d
c
a b
d c eb
b e
e
f
2020
3
5
6.8
20
a
b
e
d
c
a b d
c eb
b e
e
20 20
3
5
6.8
20
f
f
f -20
a
b
e
d
c
a b d
c eb
f e
e
-10
3
6.9
6.8
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(log2n) 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(log2 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 < log2n we are ok --- the delete takes O(log n loglog n) time
However it could be that # lines get on/off the replacement piece > log2n
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 > log2n 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(log2 n) for delete
O(log n) for find-min and insert
O(log n) for decrease-key
Fibonacci heaps (Fredman & Tarjan 84)
Want to do decrease-key(x,h,) faster than delete+insert.
( in O(1) time.)
55
6
2
6
1
85
95
10
Heap ordered (Fibonacci) trees
Linking
Operations are defined via a basic operation, called linking, of Fibonacci trees:
Produce a Fk from two Fk-1, keep heap order.
1
65
8
2
95
10
4
116
9
5
96
10
Basic idea: delay the linking until they are safe
S1S0
Sr
Regular heap
Linking
The basic operation is inserting a tree of rank r into Sr,
making the appropriate linking if needed.
Insert(i) : Insert a new node containing i into S0
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: ai = 1, increase key of i: ai := ai + 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 kth 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?