turning amortized to worst-case data structures: techniques and results
DESCRIPTION
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 - PowerPoint PPT PresentationTRANSCRIPT
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) (????)
amortizedworst-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
1
0
1
31
6 Ops
-1
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(dj) If dj = 2 then dj = 0 και dj+1
= dj+1+1
Increase(x)1. x = x+12. i = min{j:dj1}
3. Fix(dj)
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
-1
0
2
31
+1
2
0
0
-1
0
2
32
2 Ops
0
1
0
0
0
2
33
2 Ops
+1
1
1
0
-1
0
2
31
-1
1
0
-1
1
0
2
30
2 Ops
0
1
-1
1
0
2
29
2 Ops
-1
0
0
1
1
0
1
28
-1
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
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)
d
dOloglog
log
nO log nO log
nO log
nO log
dO log
dO log
dO log dO log
dO log
dO log
1O
1O
1O
nO *log 1O
1O
1O
1O
1O
nO *log
(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
4 5 6 8 9 11 13 15 17 19 21 23 24 27 31 33 34 35 37 41 42 51 53
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(T1,T2 ) Split(T,x)
T1 = 2,5,7,8,10,11 T2 = 13,17,19,34,58,79
Join(T1,T2 ) = 2,5,7,8,10,11,13,17,19,34,58,79
This talk
31 33 34 35 37 41 42 51 53
root
Catenable Sorted Lists: Search Trees (2,3-trees)
58 60 61 64 67 71 72 74 75
1. Search for appropriate position
2. Link
3. RebalanceT1
T2
Catenable Sorted Lists: Search Trees
(2,4-trees, red-black trees…)
T1
T2
1
3
2
Search
Link
Rebalance
1
2
3
Worst-case O(1)
Worst-case O(log |T1|)
Worst-case O(log |T2|)
or amortized O(1)
or O(loglog |T2|)
or worst-case O(1)
or amortized O(1)
Catenable Sorted Lists
Search trees
KaplanTarjan’96
This talk
Search log n log n log n
Insert/Delete log n log n log n
Join log n 1* loglog ns 1
Split log n log ns -
n = |T| ns = min(|T1|,|T2|) * amortized
O(1) Join and O(log n) Search
The ideas….
Problem: Nodes of arbitrary degree
Idea 1: Linking By Size
T1 T2
height O(log n)
Idea 2: Represent Nodes byWeight-Balanced Trees
Problem: Does not support linking by size in O(1) time
O(log n)O(log n)
Idea 3: Tree-Collections and Lazy Join
Tree collection
k treesk levels
Weight- balanced tree
Idea 3 (cont.): Lazy Join
Old tree collection
New tree collection
k treesk levels
Conclusion
Search trees This talk ♪Search log n log n
Insert/Delete log n log n
Join log n 1* 1
Split log n -
* amortized ♪ purely functional
Open ProblemsVery 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. Search2. Update3. Rebalance
Update Operations:
4 5 6 8 9 11 13 15 17 19 21 23 24 27 31 33 34 35 37 41 42 51 53
10f’ x
d=7f
root