# Turning Amortized to Worst-Case Data Structures: Techniques and Results Tsichlas Kostas.

## Presentation on theme: "Turning Amortized to Worst-Case Data Structures: Techniques and Results Tsichlas Kostas."— Presentation transcript:

Turning Amortized to Worst-Case Data Structures: Techniques and Results Tsichlas Kostas

Talk Structure Techniques Guaranteed Complexities of Data Structures: –The finger search tree problem [STOC 02, Brodal, Lagogiannis, Makris, Tsakalidis, Tsichlas] –The merge of search trees problem [ESA 06, Brodal, Makris, Tsichlas] Open Problems

Amortized vs Worst-Case Complexities Amortized: N operations on a set of n elements cost O(f(N,n)) time, –The mean cost of each operation is O(f(N,n)/N) –There may be operations which are expensive Worst-Case: Each operation costs O(g(n)). –Usually more complicated design that amortized structures Question: g(N)=O(f(N,n)/N) (????) amortized worst-case

Conversion Techniques to Worst-Case Complexities Incremental Scheduling of Operations: –Redundant Number Systems –Stricter Invariants on the structure –Local or Global Rebuilding

Redundant Number Systems For each number there is only one representation (usual number systems) For each number there are multiple representations (redundant number systems)

How do we Count? 1 0 1 1 0 1 30 MSB LSB +1 0 0 0 0 1 0 32 6 Ops 1 1 1 1 0 1 31 6 Ops 1 0 1 1 0 1 30 1 Op +1 1 1 1 1 0 1 31 1 Op

A New Way to Count Use 3 digits {0,1,2}, where 2 represents the carry. Between two 2s there is always a zero The first digit from the LSB different to 1 is always a 0 Fix(d j ) If d j = 2 then d j = 0 και d j+1 = d j+1 +1 Increase(x) 1.x = x+1 2.i = min{j:d j 1} 3.Fix(d j ) 1 0 1 2 0 1 546 MSB LSB 0 1 2 +1 1 1 1 2 0 1 547* 0 1 2 Fix 1 1 2 0 0 1 547 0 1 2

+ and - Use 4 digits {-1,0,1,2}, where 2 represents the carry and -1 the residue. 1 1 0 0 2 31 +1 2 0 0 0 2 32 2 Ops 0 1 0 0 0 2 33 2 Ops +1 1 1 0 0 2 31 1 0 1 0 2 30 2 Ops 0 1 1 0 2 29 2 Ops 0 0 1 1 0 1 28 2 Ops

MSB LSB Simple Counters on (2,3)-trees --A node has 3 children 1 --A node has 2 children 0 1 1 1 1 1 0 0 1 0 0 0 0

MSB LSB Redundant Counters on (2,3)-trees --A node has 3 children 1 --A node has 4 children 2 --A node has 2 children 0 --A node has 1 child -1 1 1 0 1 2 2 0

What about Arbitrary Updates? Redundant number representation cannot be used in this case because of the tree structure. Somehow we must come up with a tree counter

Known Results Insertion Deletion Search AVL-trees, (2,3)-trees (a) Red-Black trees, (2,4)-trees (a,b) Levcopoulos, Overmars 88 (a) Guibas et al. 77, Tsakalidis 85 (a,c) Harel, Lucker 79 (a) Huddleston, Mehlhorn 82 (a,b) Brodal 98 (a) Brodal et al. 02 (a) Dietz, Raman 94 (d) Andersson, Thorup 00 (e) (a) Pointer Machine (b) Amortized Complexity (c) O(1) Movable Fingers (d) Comparison RAM (e) Word RAM

Components Mechanism to identify where to rebalance Components = partition of internal nodes into subtrees 45689111315171921232427313334353741425153 Link(v) v Break(r) r Link(v) Component records with root pointers (valid or invalid)

Catenable Sorted Lists in Worst-Case Constant Time

Catenable Sorted Lists Insert(T,x) Delete(T,x) Search(T,x) Join(T 1,T 2 ) Split(T,x) T 1 = 2,5,7,8,10,11 T 2 = 13,17,19,34,58,79 Join(T 1,T 2 ) = 2,5,7,8,10,11,13,17,19,34,58,79 This talk

313334353741425153 root Catenable Sorted Lists: Search Trees (2,3-trees) 586061646771727475 1.Search for appropriate position 2.Link 3.Rebalance T1T1 T2T2

Catenable Sorted Lists: Search Trees (2,4-trees, red-black trees…) T1T1 T2T2 1 3 2 Search Link Rebalance 1 2 3 Worst-case O(1) Worst-case O(log |T 1 |) Worst-case O(log |T 2 |) or amortized O(1) or O(loglog |T 2 |) or worst-case O(1) or amortized O(1)

Catenable Sorted Lists Search trees Kaplan Tarjan96 This talk Searchlog n Insert/Deletelog n Joinlog n 1*loglog n s 1 Splitlog nlog n s - n = |T| n s = min(|T 1 |,|T 2 |) * amortized

O(1) Join and O(log n) Search The ideas….

Problem: Nodes of arbitrary degree Idea 1: Linking By Size T1T1 T2T2 height O(log n)

Idea 2: Represent Nodes by Weight-Balanced Trees Problem: Does not support linking by size in O(1) time O(log n)

Idea 3: Tree-Collections and Lazy Join Tree collection k trees k levels Weight- balanced tree

Idea 3 (cont.): Lazy Join Old tree collection New tree collection k trees k levels

Conclusion Search treesThis talk Searchlog n Insert/Deletelog n Joinlog n 1*1 Splitlog n- * amortized purely functional

Open Problems Very Hard… Dynamic Fractional Cascading (O(loglogn) worst-case) Full Persistence (O(1) worst-case) … Hard… Simple Constant Update Finger Trees Support the split operation in the constant catenable sorted list …

Finger Searching in (2,4)-trees Insertion: O(logn) w.c.t. Deletion: O(logn) w.c.t. Search: O(logd) w.c.t. 1.Search 2.Update 3.Rebalance Update Operations: 45689111315171921232427313334353741425153 10 fx d=7 f root

Download ppt "Turning Amortized to Worst-Case Data Structures: Techniques and Results Tsichlas Kostas."

Similar presentations