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

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

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

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

5. 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)

6. 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)

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

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

9. a b e d c a b d c e a a c a 3 6 6.8 4.4       

10. Simple kinetic heaps (Cont) Add minimum future swap time

11. a b e d c a b d c e a a c a 3 3 6.8 3 6 3 4.4 6.8       

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

13. a b e d c a b d c e a a c a        3 3 6.8 3 6 3 4.4 6.8

14. a b e d c a b d c e a a c a        3 3 3 6 3 4.4 6.8

15. a b e d c a b d c e b a c a        3 3 6 3 4.4 6.8        

16. a b e d c a b d c e b b  20 3        c a 3 4.4 6.8

17. a b e d c a b d c e b b  20 3        c b 5 5 6.8

18. a b e d c a b d c e b b c b  20 5 3 5        6.8

19. a b e d c a b d c e b b c b         20 5 3 5 6.8

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

21. a b e d c a b d c e b b e e         3  6.3 6.8

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

23. a b e d c a b d c e b b e e f         20 3 5  6.8 20

24. a b e d c a b d c e b b e e   3 5 6.8 20 f f f  -20       

25. a b e d c a b d c e b f e e    -10 3 6.9 6.8  f f f  -20       

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

41.       

42.       

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

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

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

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

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

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

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

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

51. 55 6 2 6 1 85 95 10 Heap ordered (Fibonacci) trees

52. 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. 1 6 5 8 2 9 5 10 4 116 9 5 96 10

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

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

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

56. 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)

57. 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?