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?