Splay Trees and Self Organizing Data Structures

CS 6213 –
Advanced
Data
Structures
SPLAY TREES
SELF ORGANIZING
DATA STRUCTURES

Instructor
Prof. Amrinder Arora
amrinder@gwu.edu
Please copy TA on emails
Please feel free to call as well
TA
Iswarya Parupudi
iswarya2291@gwmail.gwu.edu
L5 - Splay Trees CS 6213 - Advanced Data Structures - Arora 2
LOGISTICS

CS 6213
Basics
Record / Struct
Arrays / Linked
Lists / Stacks
/ Queues
Graphs / Trees
/ BSTs
Advanced
Trie, B-Tree
Splay Trees
R-Trees
Heaps and PQs
Union Find
WHERE WE ARE

David Kaplan @ Washington University
Jay Chen @ NYU Abu Dhabi / NYU Poly
Frank Ruskey @ University of Victoria
CREDITS

Data structure “self organizes” based on the
sequence of operations invoked on it, and based on
some general rules on what to do with the operation.
Different from having rules on what the data
structure should globally look like.
SELF ORGANIZING DATA STRUCTURES

Splay Tree
Is a Binary Search Tree, but is not an AVL or RB Tree
Its height is not guaranteed to be O(log(n)). In fact,
it can even be O(n).
SELF ORGANIZING BINARY SEARCH TREE

splā/ verb
thrust or spread (things, esp. limbs or fingers) out
and apart.
SPLAY

Relax – let the rules break overall
Don’t be so uptight
Focus on amortized time, not just worst case time.
MOTIVATION FOR SPLAY TREES

Problems with AVL Trees
 Extra storage/complexity for height fields
 Ugly delete code
Solution: splay trees
 Blind adjusting version of AVL trees
 Amortized time for all operations is O(log n)
 Worst case time is O(n)
 Insert/find always rotates nodes and makes the new/found
node to be the new root, so its future accesses are faster
MOTIVATION FOR SPLAY TREES (CONT.)

SPLAY TREE IDEA
17
10
92
5
3
Since the tree does not
have a bounded height,
you may be forced to
make a really deep access:
Since you’re down there anyway,
fix up a lot of deep nodes!

Node being accessed (n) is:
 Root
 Child of root
 Has both parent (p) and grandparent (g)
Zig-zig pattern: g  p  n is left-left or right-right
Zig-zag pattern: g  p  n is left-right or right-left
SPLAYING CASES

ACCESS ROOT:
DO NOTHING
X
n
Y
root
X
n
Y
root

ACCESS CHILD OF ROOT:
ZIG (AVL SINGLE ROTATION)
p
X
n
Y
Z
n
Z
p
Y
X
root root

ACCESS (LR, RL) GRANDCHILD:
ZIG-ZAG (AVL DOUBLE ROTATION)
g
X
p
Y
n
Z
W
n
Y
g
W
p
ZX

ACCESS (LL, RR) GRANDCHILD:
ZIG-ZIG
n
Z
Y
p
X
g
W
g
W
X
p
Y
n
Z
Rotate top-down – why?

SPLAYING EXAMPLE:
FIND(6)
2
1
3
4
5
6
Find(6)
2
1
3
6
5
4
zig-zig

… STILL SPLAYING …
zig-zig
2
1
3
6
5
4
1
6
3
2 5
4

… 6 SPLAYED OUT!
zig
1
6
3
2 5
4
6
1
3
2 5
4

ANOTHER EXAMPLE
FIND (4)
Find(4)
zig-zag
6
1
3
2 5
4
6
1
4
3 5
2

… 4 SPLAYED OUT!
zig-zag
6
1
4
3 5
2
61
4
3 5
2

If a node n on the access path is at depth d before
the splay, it’s at about depth d/2 after the splay
 Exceptions are the root, the child of the root, and the node
splayed
Overall, nodes which are below nodes on the access
path tend to move closer to the root
Splaying gets amortized O(log n) performance. (Not
easy to prove)
WHY SPLAYING HELPS

Find the node in normal BST manner
Splay the node to the root
SPLAY OPERATIONS: FIND

Just do BST insert
Then, splay to the root.
SPLAY OPERATIONS: INSERT

SPLIT
split(x)
T L R
splay
OR
L R L R
 x  x> x < x

SPLAY OPERATIONS: DELETE
find(x)
L R
x
L R
> x< x
delete x
Now what?

Join(L, R): Given two trees such that L < R, merge
them
Splay on the maximum element in L, then attach R
JOIN
L R R
splay
L

DELETE COMPLETED
T
find(x)
L R
x
L R
> x< x
delete x
T - x
Join(L,R)

INSERT EXAMPLE
Insert(5)
91
6
4 7
2
split(5)
9
6
7
1
4
2
1
4
2
9
6
7
1
4
2
9
6
7
5

DELETE EXAMPLE
91
6
4 7
2
Delete(4)
find(4)
9
6
7
1
4
2
1
2
9
6
7
Find max
2
1
9
6
7
2
1
9
6
7

Unsorted List
 Access(x) – Costs i, if x is at the i-th location.
 Delete(x) – Costs i, if x is at the i-th location.
 Insert(x) – Costs n+1 if list has n elements
Standard Cost Model
 Cost of operation
 Free inversion – Move the element anywhere to the front
 Paid inversion – Swap any two elements
ANOTHER EXAMPLE OF SELF
ORGANIZING DATA STRUCTURES

Moves the accessed item to the front of the list
 (Other algorithms: Transpose, Frequency Count)
This is the simple idea behind self adjustment.
Similar idea is used in caching algorithms also.
This also introduces us to online algorithms, because
we do not know what the future part of request
sequence will look like.
SELF ADJUSTMENT: “MOVE TO FRONT”
ALGORITHM

 Amortized Cost Analysis: Consider the worst case cost
over multiple operations
 Different from average cost analysis – over “probabilistically
average case” for one operation
 We compare the performance of MTF algorithm to an
Optimal algorithm which knows the full request sequence
in advance and can use that to organize the list.
 Request sequence: s1, s2, … sn
 Frequently used idea in amortized analysis: Potential
function: f(t).
 In context of MTF, we define f(t) to be the number of
“inversions” between the MTF list and the OPT list.
 Key Result: C_MTF(t) + f(t) – f(t – 1) <= 2 C_OPT(t) – 1
 This leads to: C_MTF <= 2 C_OPT overall. (Impressive.)
ANALYSIS OF “MOVE TO FRONT”
ALGORITHM

 Self-tuning data structure
 Operations tune the data structure automatically, based on
some rules
 Final state of the data structure depends upon the sequence of
operations
 Splaying Philosophy
 Keeps most-recently used (MRU) nodes higher up
 Main Results
 Any m consecutive operations starting from an empty tree take
at most O(m log(n)) time, where n is the number of inserts.
 That is, all splay tree operations run in amortized O(log n) time
 O(n) operations can occur, but splaying makes them infrequent
CONCLUSIONS: SPLAY TREE

Splay trees are very effective search trees
Relatively simple: no extra fields required (height
of subtree, color, rank, etc.)
Excellent locality properties:
 Frequently accessed keys are cheap to find (near top of tree)
 Items near an accessed item are also pulled towards the
root.
 Infrequently accessed keys stay out of the way (near bottom
of tree)
CONCLUSIONS: SPLAY TREE (CONT.)

Splay Trees and Self Organizing Data Structures

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Splay Trees and Self Organizing Data Structures

Similar to Splay Trees and Self Organizing Data Structures (20)

More from Amrinder Arora

More from Amrinder Arora (17)

Recently uploaded

Recently uploaded (20)

Splay Trees and Self Organizing Data Structures