Uniquely Represented Data StructuresAdvanced Algorithms & Data Structures

Lecture Theme 10

Prof. Dr. Th. Ottmann

Summer Semester 2006

2

Motivation

A structure storing a set of keys is called oblivious, if it is not possible to infer its

generation history from its current shape.

A structure is called persistent, if it supports access to multiple versions.

Partially persistent: All versions can be accessed but only the newest version can be

modified.

Fully persistent: All versions can be accessed and modified.

Confluently persistent: Two or more old versions can be combined into one new

version.

3

Methods for making structures oblivious

Unique representation of the structure:

• Set/size uniqueness: For each set of n keys there is exactly one structure which

can store such a set.

• The storage is order unique, i.e. the nodes of the strucure are ordered and the

keys are stored in ascending order in nodes with ascending numbers.

Randomise the structure:

Assure that the expectation for the occurrence of a structure storing a set M of

keys is independent of the way how M was generated.

Observation: The address-assingment of pointers has to be subject under a

randomised regime!

4

Example of a randomised structure

Z-stratified search tree

On each stratum, randomlychoose the distribution oftrees from Z.

Insertion?Deletion?

… …

… … ....

…..

…..

5

Uniquely represented structures

(a) Generation history determines structure

(b) Set-uniqueness:Set determines structure

1, 3, 5, 7 5, 1, 3, 7

1, 3, 5, 7

13

57

3

1

5

7

13

57

6

Uniquely represented structures

(c) Size-uniqueness:Size determines structure

1, 3, 5, 7

2, 4, 5, 8 Common structure

Order-uniqueness: Fixed ordering of nodes determines where the keys are to be stored.

1

3

2

4

2

4

5

8

1

3

5

7

7

Set- and order-unique structures

Lower bounds?

Assumptions: A dictionary of size n is represented by a graph of n nodes.

Node degree finite (fixed),

Fixed order of the nodes,

i-th node stores i-largest key.

Operations allowed to change a graph:

Creation | Removal of a node

Pointer change

Exchange of keys

Theorem: For each set- and order-unique representation of a dictionary with n keys, at

least one of the operations access, insertion, or deletion must require time (n1/3).

8

Uniquely represented dictionaries

Problem: Find set-unique oder size-unique representations of the ADT „dictionary“

Known solutions:

(1) set-unique, oder-unique

Aragon/Seidel, FOCS 1989: Randomized Search Trees

universal

hash-function

Update as for priority search trees!

Search, insert, delete can be carried out in O(log n) expected time.

(s, h(s))

priority

s Î X

9

The Jelly Fish

(2) L. Snyder, 1976, set-unique, oder-unique

Upper Bound: Jelly Fish, search insert delete in time O(n).

body: n nodes

n tentacles of length n each

10

5

1

2

3

6

7

8

11

12

10

Lower bound for tree-based structures

set-unique, oder-unique

Lower bound: For “tree-based” structures the following holds:

Update-time · Search-time = Ω (n)

Number of nodes n ≤ h L + 1

L ≥ (n – 1)/h

At least L-1 keys must have moved from leaves to internal nodes. Therefore, update requires time Ω(L).

Delete x1

Insert xn+1 > xn

L leaves

·

xnx1

h

11

Cons-structures

(3) Sunder/Tarjan, STOC 1990, Upper bound: (Nearly) full, binary search trees

Einzige erlaubte Operation für Updates:

Search time O(log n)

EinfügenEntfernen in Zeit O(n) möglich

·

··

·31 15 353

L Rx L R

x

Cons, ,

12

Jump-lists

(Half-dynamic) 2-level jump-list

2-level jump-liste of size n

niini 22 )1(

Search: O(i) = O( ) timeInsertion: Deletion: O( ) time

n

n

22 4113

tail

0 i 2i n

(n-1)/i · i

2 3 5 7 8 10 11 12 14 17 19

13

Jump-lists: Dynamization

2-level-jump-list of size n niini 22 )1(

22 4113

search: O(i) = O(n) timeinsert delete

: O(n) time

Can be made fully dynamic:

(i-1)2 i2 n (i+1)2 (i+2)2

tail

0 i 2i n

(n-1)/i · i

2 3 5 7 8 10 11 12 14 17 19

14

3-level jump-lists

33 )1( ini

33 43,30 nnin 3

level 2

Search(x): locate x by followinglevel-2-pointers identifying i2 keys among which x may occur,level-1-pointers identifying i keys among which x may occur,level-0-pointers identifying x

time: O(i) = O(n1/3)

0 i 2i i2 i2+i 2·i2

15

3-level jump-lists

33 )1( ini

33 43,30 nnin 3

level 2

Update requiresChanging of 2 pointers on level 0Changing of i pointers on level 1Changing of all i pointers onlevel 2

Update time O(i) = O(n1/3)

0 i 2i i2 i2+i 2·i2

16

c-level jump-lists

Let

Lower levels:

level 0: all pointers of length 1:

...

level j: all pointers of legth ij-1:

...

level c/2 : ...

Upper levels:

level j: connect in a in list all nodes

1, 1·ij-1+1, 2· ij-1+1, 3· ij-1+1, ...

level c:

cc ini )1(

17

c-level jump-lists

Theorem:

For each c ≥ 3, the c-level jump-list is a size and order-unique representation

of dictionaries with the following characteristics:

Space requirement O(c·n)

Access time O(c·n1/c)

Update time , if n is even

, if n is odd

)( nO

)( 2/)1( ccnO

18

1 top-level tree with n leavesAll low-level trees for each sequence of n consecutive keys

Top-level tree direct search to the root of the currently active low-level treesSemi-dynamic structure: )1(22 22 kk n

12,)12( kk rrsn

low-level-tree-sizes+1 = top-level-tree-size )( nO

Shared-search-trees

Reduction of search time

19

Shared-search-trees

Pointers at:

Level 0 : (p-20) p (p+ 20)

Level 1 : (p-21) p (p+ 21)

…

Level k-2 : (p-2k-2) p (p+ 2k-2)

2(k-1) Pointers per node p, k = O(log n)

Search time O(log n)Space O(n log n)

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

1

0

20

Insertion: Determine insertion position;Change all pointers jumping over the insertion position;Add 2 new pointers per level;Completely rebuild top-level tree.

)1(22 22 kk n

0

1

21

Number of pointerchanges: level 0:

2·20+2level 1:

2·21+2…level k-2:

2·2k-2+2 2·(2k-1-1)+2(k-1) =

)nO(

)1(22 22 kk n

0

1

22

Shared search trees: Summary

Theorem: Shared search trees are a size- und order-unique representation of

dictionaries with the following characteristics:

Space requirement: O(n log n)

Search time: O(log n)

Upadate time: O( n )

Open problem:

Is there a size- and order-unique representation of by graphs with bounded node

degree, search time O(log n), and update time o(n) (e.g.. O(n))?