[PPT] - Splay Trees Mark Redekopp 2 Sources / Reading Material for these PowerPoint Presentation

SLIDE 1

1

CSCI 104 Splay Trees

Mark Redekopp

SLIDE 2

2

Sources / Reading

Material for these slides was derived from the

following sources

– https://www.cs.cmu.edu/~sleator/papers/self- adjusting.pdf – http://digital.cs.usu.edu/~allan/DS/Notes/Ch22.pdf – http://www.cs.umd.edu/~meesh/420/Notes/MountNotes /lecture10-splay.pdf

Nice Visualization Tool

– https://www.cs.usfca.edu/~galles/visualization/SplayTree. html

SLIDE 3

3

Splay Tree Intro

Another map/set implementation (storing keys or key/value pairs)

– Insert, Remove, Find

Recall…To do m inserts/finds/removes on an RBTree w/ n

elements would cost?

– O(m*log(n))

Splay trees have a worst case find, insert, delete time of…

– O(n)

However, they guarantee that if you do m operations on a splay

tree with n elements that the total ("amortized"…uh-oh) time is

– O(m*log(n))

They have a further benefit that recently accessed elements will

be near the top of the tree

– In fact, the most recently accessed item is always at the top of the tree

SLIDE 4

4

Splay Operation

Splay means "spread"
As you search for an item or after

you insert an item we will perform a series of splay operations

These operations will cause the

desired node to always end up at the top of the tree

– A desirable side-effect is that accessing a key multiple times within a short time window will yield fast searches because it will be near the top – See next slide on principle of locality

R T T

If we search for or insert T… …T will end up as the root node with the old root in the top level or two

R

SLIDE 5

5

Principle of Locality

2 dimensions of this principle: space & time
Spatial Locality – Future accesses will likely cluster

near current accesses

– Instructions and data arrays are sequential (they are all

ne after the next)
Temporal Locality – Future accesses will likely be to

recently accessed items

– Same code and data are repeatedly accessed (loops, subroutines, if(x > y) x++; – 90/10 rule: Analysis shows that usually 10% of the written instructions account for 90% of the executed instructions

Splay trees help exploit temporal locality by

guaranteeing recently accessed items near the top of the tree

SLIDE 6

6

Splay Cases

G P X

a b c

G P X

b c a

G P X

b c a

1. 2. 3.

Zig-Zig

d

R X

b a

X P G

c d b a c

R

c

X

a b Right rotate of X,R d d

1 2 X P G

a b c d

X G P

a b c d

1 2

Zig-Zag

Leftrotate of X,R

Root/Zig Case (Single Rotation)

SLIDE 7

7

Find(1)

6 7 5 4 3

Zig-Zig

2 1 6 7 5 4 1 2 3 6 7 1 2 3 4 5 1 6 2 3 4 5 7

Zig-Zig Zig Resulting Tree

SLIDE 8

8

Find(3)

Notice the tree is starting to look at lot more

balanced

Zig-Zag Resulting Tree

1 6 2 3 4 5 7 1 6 2 3 4 7 5 3 6 2 1 4 7 5

Zig-Zag

SLIDE 9

9

Worst Case

Suppose you want to make the amortized time

(averaged time over multiple calls to find/insert/remove) look bad, you might try to always access the ______________ node in the tree

– Deepest

But splay trees have a property that as we keep

accessing deep nodes the tree starts to balance and thus access to deep nodes start by costing O(n) but soon start costing O(log n)

SLIDE 10

10

Insert(11)

20 30 12 15 25 5 3 10 8

Resulting Tree

20 30 12 15 25 5 3 10 8 11

Zig-Zig

20 30 12 15 25 11 10 5 3 8 20 30 12 15 25 11 10 5 3 8

Zig-Zig

SLIDE 11

11

Insert(4)

20 30 12 15 25 5 3 10 8

Resulting Tree Zig-Zag Zig-Zig

20 30 12 15 25 5 3 10 8 4 20 30 12 15 25 4 3 5 8 10 20 30 25 4 3 12 15 5 8 10

SLIDE 12

12

Activity

Go to

– https://www.cs.usfca.edu/~galles/visualization/SplayTree. html – Try to be an adversary by inserting and finding elements that would cause O(n) each time

SLIDE 13

13

Splay Tree Supported Operations

Insert(x)

– Normal BST insert, then splay x

Find(x)

– Attempt normal BST find(x) and splay last node visited

If x is in the tree, then we splay x
If x is not in the tree we splay the leaf node where our search ended
FindMin(), FindMax()

– Walk to far left or right of tree, return that node's value and then splay that node

DeleteMin(), DeleteMax()

– Perform FindMin(), FindMax() [which splays the min/max to the root] then delete that node and set root to be the non-NULL child of the min/max

Remove(x)

– Find(x) splaying it to the top, then overwrite its value with is successor/predecessor, deleting the successor/predecessor node

SLIDE 14

14

FindMin() / DeleteMin()

20 30 12 15 25 5 3 10 8

Resulting Tree Zig-Zig Zig

20 30 5 12 25 10 8 3

FindMin() DeleteMin() Resulting Tree

15 20 30 5 12 25 10 8 3 15 20 30 5 12 25 10 8 3 15 20 30 5 12 25 10 8 15

SLIDE 15

15

Remove(3)

Zig-Zag Resulting Tree

1 6 2 3 4 5 7 1 6 2 3 4 7 5 3 6 2 1 4 7 5

Zig-Zag

3 6 2 1 4 7 5 4 6 2 1 5 7

Copy successor or predecessor to root Delete successor (Remove node or reattach single child)

SLIDE 16

16

Top Down Splaying

Rather than walking down the

tree to first find the value then splaying back up, we can splay

n the way down
We will be "pruning" the big

tree into two smaller trees as we walk, cutting off the unused pathways

SLIDE 17

17

Top-Down Splaying

T 2.

Final Step (when reach Target)

L R T L R a b b a

Root

T 1.

Zig (If Target is in 2nd level)

b

a L R

Root

T

b

a L R

SLIDE 18

18

Top-Down Splaying

3.

Zig-Zig

X Y Z

b c

X Y Z

b a

L R a X Y Z

b c

L R a c L R Z c R L X Y

b a

4.

Zig-Zag

L R b X Z

c

L R b X Y Z

a c

Y

a

L R b Y Z

c

L R b X Y Z

c a

X

a

SLIDE 19

19

Find(3)

Zig-Zag

1 6 2 3 4 5 7

Steps taken on

ur journey to

find 3

6

L R b Y Z

c

L R b X Y Z

c a

X

a

1

L-Tree R-Tree L-Tree R-Tree

7 2 3 4 5

L R b X Z

c

L R b X Y Z

a c

Y

a

6

R-Tree

7 4 5 1

L-Tree

2 3

SLIDE 20

20

Find(3)

R-Tree

1

L-Tree

2 3

T 2.

Final Step (when reach Target)

L R T L R a b b a

6 7 4 5 1 2 6 7 4 5 3

Resulting tree from bottom-up approach

3 6 2 1 4 7 5

Resulting tree after find

SLIDE 21

21

Insert(11)

20 30 12 15 25 5 3 10 8

Original Resulting Tree from Bottom- up approach

20 30 12 15 25 11 10 5 3 8

L-Tree

R-Tree

5 3 10 8

L-Tree

12 20 15 30 25

R-Tree

10 5 3 8 12 20 15 30 25

R-Tree

11

L-Tree

SLIDE 22

22

Summary

Splay trees don't enforce balance but are self-

adjusting to attempt yield a balanced tree

Splay trees provide efficient amortized time
perations

– A single operation may take O(n) – m operations on tree with n elements => O(m(log n))

Uses rotations to attempt balance
Provides fast access to recently used keys