Splay Trees Advanced)

transcript

Splay Trees

Amna Humayun

Splay Trees

Self-adjusting form of binary search tree. A splay rotation consist of a sequence of

rotations.

They follow the heuristicMove to the root

Rotation

Rotation plays an important role in Splay

trees.

Types of rotation: Left-Rotation Right-Rotation

Left-Rotation

Right-Rotation

Use of Splay Trees

In many applications, when a node is accessed, it is likely to be accessed again in the near future.

The central idea of splay is

If a node is deep, there are many node on the path that are relatively deep, and then

restructuring make future accesses cheaper on all these nodes.

Types of Splay Trees

Bottom-Up Splay Trees Top-Down Splay Trees

Bottom-Up Splay Trees

Similar to binary search tree. Search, insert and delete operations are

performed in the same way, except that they are followed by splay.

In split, however first splay is performed. Bottom-up splay rotations are performed along

the path from the start node to the root of the binary search tree.

Simple idea

One way of performing restructuring is to perform single rotations, bottom-up.

Rotate every node on the access path with its parent.

Example — Search(p1) Search(p1)

Example — Search(p1) Perform single rotation bottom-up.

p3p3p3

Example — Search(p1)

The rotations have pushed p1 to the root, for easy future access. But, it has pushed another node p3

almost as deep as p1 used to be.

Original Tree

SPLAYING

The splaying strategy is similar to rotation idea, except that it a little more selective about how rotations are performed.

Steps for Splay

Let x be the node at which splay is being performed.

If x is a root, then splay terminates. If x is a non-root node and x has parent (p) but

no grandparent — zig case. If x is a non-root node and x has both parent (p)

and grandparent (g), then there are two cases:Zig-Zig CaseZig-Zag Case

Steps for Splay…ZIG CASEIf x is the left child of p perform right rotation around p.

cRight-Rotation

Steps for Splay… ZIG CASE (symmetric)

If x is the right child of p perform left rotation around p.

cLeft-Rotation

Steps for Splay…ZIG-ZIG CASE If x is the left child of p, and p is also the left child of g. Perform right rotation around g. Perform right rotation around p.

Steps for Splay…ZIG-ZIG CASE (symmetric)If x is the right child of p, and p is also the right child of g. Perform left rotation around g. Perform left rotation around p.

Steps for Splay…ZIG-ZAG CASE If x is the left child of p, and p is the right child of g. Perform right rotation around p. Perform left rotation around g.

Steps for Splay…ZIG-ZAG CASE (symmetric)If x is the right child of p, and p is the left child of g. Perform left rotation around p. Perform right rotation around g.

Search

If the search is successful, then it must end at a particular node and the start node of splay is that particular node.

If the search is unsuccessful, then it must end at some external node and the start node of splay is the parent of that external node.

Example Search(p1) — Using Splay Search(p1). Search is successful.

Example Search(p1) — Using Splay Perform splay bottom-up from p1.

p1p1p1zig-zag

Perform splay bottom-up from p1.

zig-zag

Example Search(p1) — Using Splay

zig-zag

zig-zig

zig-zigp4p4

p2p4p4

Splaying not only moves the accessed node to the root, but also has the effect of roughly halving the depth of

most nodes on the access path.

Original Tree

Insert

If the element to be inserted is already present in the tree, then the start node of splay is the node containing that particular element.

If the element to be inserted is not present in the tree, then insert element in the tree and the start node of splay is the newly inserted node.

Insert(36)

Search(36) Element not found. Insert 36.

5 13 20 37

Insert(36)

Perform splay bottom-up from 36.

5 13 20 37

zig-zag

Insert(36)

5 13 20 zig-zag

37373737

Insert(36)

5 13 20 zig-zag

Insert(36)

20 3636

zig-zig

Insert(36)

20 3636

zig-zig

Insert(36)

zig-zig3131

Insert(36)

373131

Original Tree

5 13 20 37

Delete

If the element to be deleted is present in the tree, then the node containing that element is deleted, and the start node of splay is the parent of the deleted node.

If the element to be deleted is not present in the tree, unsuccessful search must end at some external node, and the start node of splay is the parent of that external node.

Delete(36)

Search(36) Element found. Delete 36.

5 13 20 37

Delete(36)

Perform splay bottom-up from parent of 36 i.e. 35.

5 13 20

zig-zag

Delete(36)

5 13 20

zig-zag

Delete(36)

zig-zag

Delete(36)

zig-zag

Delete(36)

16 zig16

Delete(36)

16 zig

Delete(36)

Original Tree

5 13 20 37

Delete(16)

Search(16) Element found. Delete 16. 35

delete by copy

Delete(16)

Search(16) Element found. Delete 16. 35

Delete(16)

zig-zag

Delete(16)

zig-zag

202020

31313131

202020

Delete(16)

353535zig-zag

Delete(16)

353535zig-zag

Delete(16)

353135

Original Tree

Split (similar to search) Search the node on which split is to be performed.

If the search is successful, then it must end at a particular node and the start node of splay is that particular node.

If the search is unsuccessful, then it must end at some external node and the start node of splay is the parent of that external node.

Split return two trees one contain all items in the tree less than or equal to searched node, the other tree contain all items in tree greater than searched node.

Split (at 40) Search(40) Search is successful.

20 8050

20 6040

Split (at 40) Perform splay bottom-up from 40.

20 8050

20 6040

zig-zag

505050

3030zig-zag

505050

zig-zag

505050

204040

303030

505050

204040

303030

505050

204040

303030

707070zig

505050

Split (at 40) Perform split at 40.

707070

505050

204040

303030

Split (at 40)

707070

505050

204040

303030

Original Tree

20 8050

20 6040

Amortized Analysis Lemma If a + b ≤ c, and a and b are both positive integers, then loga + logb ≤ 2 logc -2

Proof By the arithmetic-geometric mean inequality, ab ≤ (a + b)/2 Thus ab ≤ c /2 Squaring both sides gives ab ≤ c2 /4 Taking logarithms of both sides log(ab) ≤ log(c2 /4) loga + logb ≤ 2 logc -2

Amortized Analysis Amortized Time (AmT) = Actual Time for the ith operation (AcT) +

(Potential Cost of ith operation (Pi) – Potential Cost of (i-1)th operation (Pi-1) )

AmT = AcT + (Pi – Pi-1 ) Potential function Ф(T) = Σ log s(i)

where s(i) = Number of descendants of i + i itself. r(i) = log s(i) (Rank of node i) Then Ф(T) = Σ r(i) Benefit of the potential function A splay rotation can only change the rank of x , p and g. where r (x) and r '(x) is the rank before and after rotation.

i Є T

Theorem The amortized time to splay a tree with root T at node x is at most

3( r(T) - r(x) ) +1= O(log N).

Proof If x is the root of T, then there are no rotations.

Potential change = 0.

AcT = 1 (cost to access the node)

AmT = AcT + (Pi – Pi-1 )

AmT = 1 + 0

Amortized Analysis

Cost of zig case

AcT = 1 (cost of single rotation)

Pi = r '(x)+ r '(p)

Pi-1= r (x)+ r (p)

AmT = 1 + r '(x)+ r '(p) - r (x) - r (p) since only x and p can change rank

AmT ≤ 1 + r '(x) - r (x) since r (p) ≥ r '(p)

AmT ≤ 1 +3( r '(x) - r (x)) since r' (x) ≥ r (x)

Amortized Analysis

Original Tree Final Tree

For more detail

Cost of zig-zig case

AcT = 2 (cost of double rotation)

Pi = r '(x) + r '(p) + r '(g)

Pi-1= r (x) + r (p) + r (g)

AmT = 2 + r '(x)+ r '(p) + r '(g) - r (x) - r (p) - r (g) since only x, p and g can change rank

AmT = 2 + r '(p) + r '(g) - r (x) - r (p) since r '(x) = r (g)

AmT ≤ 2 + r '(p) + r '(g) - 2 r (x) since r (x) ≤ r (p)

AmT ≤ 2 + r '(x) + r '(g) - 2 r (x) —— (1) since r '(x) ≥ r '(p)

Amortized Analysis

s '(x) +s '(g) ≤ s '(x) from figure

log s '(x) + log s '(g) ≤ 2 log s '(x) -2 from lemma

r '(x) + r '(g) ≤ 2 r '(x) – 2 by definition of rank

AmT ≤ 2 + r '(x) + r '(g) – 2 r (x) Putting the value in equation 1

AmT ≤ AmT ≤ 2 + r '(x) + r '(g) + r (x) – 3 r (x)

AmT ≤ 3( r '(x) - r (x) )

Amortized Analysis

For more detail

Cost of zig-zag case

AcT = 2 (cost of double rotation)

Pi = r '(x) + r '(p) + r '(g)

Pi-1= r (x) + r (p) + r (g)

AmT = 2 + r '(x)+ r '(p) + r '(g) - r (x) - r (p) - r (g) since only x, p and g can

change rank

AmT = 2 + r '(p) + r '(g) - r (x) - r (p) since r '(x) = r (g)

AmT ≤ 2 + r '(p) + r '(g) - 2 r (x) —— (1) since r (x) ≤ r (p)

Amortized Analysis

s '(p) +s '(g) ≤ s '(x) from figure

log s '(p) + log s '(g) ≤ 2 log s '(x) -2 from lemma

r '(p) + r '(g) ≤ 2 r '(x) – 2 by definition of rank

AmT ≤ 2 + r '(p) + r '(g) – 2 r (x) Putting the value in equation 1

AmT ≤ 2( r '(x) - r (x) )

AmT ≤ 3( r '(x) - r (x) ) since 2( r '(x) - r (x) ) ≤ 3( r '(x) - r (x) )

Amortized Analysis

For more detail

Since the last splaying step leaves x at the root T.

The amortized bound of entire splay is

Amortized Analysis

3( r '(T) - r (x)) + 1 = O( log N)

Top-Down Splay Trees

Similar to bottom-up search trees, top-down splay trees consists of a sequence of rotations.

Splay rotations are performed along the path from root to the splay node (start node of bottom-up splay tree) of the binary search tree.

Top-Down Splay Trees…

Steps for Splay

Partition the binary search tree into three components.

Original Tree Right Tree (R) Left Tree (L)

L and R are initially empty. They are reassembled

with the new root of the original tree in the end.

null null null null

Steps for Splay

Reassemble

Attach left child of the new root of original tree as the right child of largest element in L.

Attach right child of the new root of original tree as the left child of smallest element in R.

Attach right child of L as the left child of new root of original tree.

Attach left child of R as the right child of new root of original tree.

Steps for Splay…

Let x be a node. If x is the splay node, then splay terminates. If x is a non- splay node and x has child (c) —

zig case. If x is a non-splay node and x has both child (c)

and grandchild (gc), then there are two cases:Zig-Zig CaseZig-Zag Case

Steps for Splay… ZIG CASE If c is the left child of x. Attach x and its right child as a left child of the smallest item in R. x is the new smallest item in R. c is now the new root of original tree.

null null

null null null null nullnull

Steps for Splay… ZIG CASE (symmetric) If c is the right child of x. Attach x and its left child as a right child of the largest item in L. x is the new largest item in R. c is now the new root of original tree.

null nullnull nullnull nullnull null

Steps for Splay…

For the zig case to apply

c needs not to be a leaf node. If the item to be searched for is smaller than c, and c

has no left child but has a right child. If the item to be searched for is greater than c, and c has no right child but has a left child.

Steps for Splay… ZIG-ZIG CASE If gc is the left child of c and c is the left child of x. Perform right rotation around x. Attach c and its right child as a left child of the smallest item in R. c is the new smallest item in R. gc is now the new root of original tree.

L RL R

cnull null null null

null null null null

Steps for Splay… ZIG-ZIG CASE (symmetric) If gc is the right child of c and c is the right child of x. Perform left rotation around x. Attach c and its left child as a right child of the largest item in L. c is the new largest item in L. gc is now the new root of original tree.

L RL Rx

null nullnull null

Steps for Splay… ZIG-ZAG CASE If gc is the left child of c and c is the right child of x. Attach x and its left child as a right child of the largest item in L. x is the new largest item in L. c is now the new root of original tree.

L RL R

pnull nullnull null

null nullnull null

Steps for Splay… ZIG-ZAG CASE (symmetric) If gc is the right child of c and c is the left child of x. Attach x and its right child as a left child of the smallest item in R. x is the new smallest item in R. c is now the new root of original tree.

s null nullnull null null null null null

Search

Let x is the node to be searched. Perform splay rotations along the path from root

to the splay node (x). If the search is successful, then splay must end at a

searched node, which is now the new root of the original tree.

If the search is unsuccessful, then splay must end at a particular node greater than/ less than the node to be searched and this particular node is now the new root of the original tree.

Reassemble the three trees in the end.

Search(19) Search(19) by performing splay.

5 8050

20 3020

5 8050

20 3020

20null null null null

301212

20 3040

zig-zag

12null null nullnull

301212

502525

zig-zig

null null null

301212

502525

zig-zig

nullnull null

301212 2040

502525

Element not found .

null null

Search(19) Reassemble.

301212 2040

502525

null null

Search(19) Reassemble.

502525

301212

nullnullnullnull

Search(19)

Bottom-Up Splay Tree

502525

301212

Top-Down Splay TreeOriginal Tree

5 8050

20 3020

Insert Let x is the node to be inserted. Create a new node (z). If tree is empty, a one-node tree is created. Otherwise perform splay rotations along the path from

root to the splay node (x). If the element to be inserted is already present in the

tree, then discard the z. If the element to be inserted is not present in the tree.

If the new root of original tree contains a value larger than the z Attach new root and its right subtree to the right of a z.

If the new root of original tree contains a value smaller than the z Attach new root and its left subtree to the left of a z.

Insert(80) Create a new node 80

Insert(80) Search(80) by performing splay.

zig-zig

null null null null

Insert(80) Search(80) by performing splay.

zig-zig30

5050RL

null null null null

Insert(80)

Search(80) by performing splay.

zig-zigRL

null null nullnull

Insert(80)

Element not found . 80

70 100100

70null null null

Insert(80)

Element not found . 80

70 100100

90null nullnull

Insert(80)

Insert 80.

70 < 80

null null

Insert(80) Attach 70 and its left sub tree to the left of 80.

906565

707070

null null

Insert(80)

Reassemble.

707070

null null

Insert(80)

Reassemble.

50507070

null nullnull null

Insert(80)

Original TreeBottom-Up Splay Tree

20 9060

505070

Top-Down Splay Tree

Insert(33) Search 33 by performing splay. 33

nullnull

zig-zig

nullnull

Insert(33) Search 33 by per forming splay.

zig-zig

nullnull

zig-zig

nullnull

Element not found .

nullnull

null null

373535

Insert(33) Insert 33. 35 > 33 33

null null

Insert(33) Attach 35 and its right sub tree to the right of 33.

null null

Insert(33) Reassemble.

null null

Insert(33) Reassemble.

null3131

Original Tree

Top-Down Splay Tree

Insert(33)

Delete Let x be the node to be deleted. Perform splay rotations along the path from root to the splay node (x). If the element to be deleted is not present in the tree, the simply return. If the element to be deleted is present in the tree.

If the left child of new root of original tree is null. Make its right child the new root. Delete x. Reassemble.

If the left child of new root of original tree is not null. Find maximum from the left sub tree by performing splay. Make it the new root. Attach right child to it. Delete x. Reassemble.

If both the left and right of new root of original tree are null. Delete x. Reassemble L and R by attaching right child of L as the left child of smallest item in R.

Delete(70) Search(70) by performing splay.

zig-zig

4545RL

nullnullnullnull

zig-zig29

5045RL

nullnullnullnull

zig-zigRL

nullnullnull

Delete(70) Element found.

nullnullnull

Delete(70) Element found.

Empty85

nullnullnull

Delete(70) Left child of 70 is null. Make its right child the new root.

nullnull null

Delete(70) Delete 70.

7070 80

8375nullnull

Delete(70) Reassemble

8375nullnull

Delete(70) Reassemble

5045 75

nullnull null null

Delete(70)

Original Tree

5045 75

Top-Down Splay Tree

Element found.

zig-zag

nullnullnullnull

Delete(40) Search(40) by performing splay. Element found.

zig-zag

55 nullnullnull

35 nullnull null

Delete(40) Both left and right of 40 are null. Reassemble L and R by attaching right child of L as the left child of

smallest item in R.

555535

35 nullnull nullnull

5555nullnull nullnull

Delete(40)

Original Tree

Top-Down Splay Tree

zig-zag

nullnullnullnull

zig-zag

nullnullnull

60 nullnull

Delete(69) Left child of 69 is not null. Find maximum from left subtree of 69 by performing splay.

nullnull

null null

zig nullnull

null null

zig nullnull

nullnull null

Delete(69) 67 is now the new root.

nullnull

null null

Delete(69) Attach right child of 69 as right child of 67.

nullnull 67

Delete(69) Reassemble.

nullnull 67

Delete(69) Reassemble.

null 6760

null null67

Delete(69)

Original Tree

62 120

Bottom-up Splay Tree

6565 120

Top-Down Splay Tree

Amortized Cost

Search O(logn)

Insert O(logn)

Delete O(logn)

References

Daniel Dominic Sleator, Robert Endre Tarjan, “Self-Adjusting Binary Search Trees” ,Journal of the

Association for Computing Machinery, Vol. 32, No. 3, July 1985, pp. 652-686.

Mark Allen Weiss, “Data Structures and Algorithm Analysis in C (2nd Edition)”, Addison-Wesley, 1995 .

Cost of zig case

AcT = 1 (cost of single rotation)

Pi = r '(x)+ r '(p)

Pi-1= r (x)+ r (p)

AmT = AcT + (Pi – Pi-1 ) since only x and p can change rank

AmT = 1 + r '(x)+ r '(p) - r (x) - r (p) since r (p) ≥ r '(p)

AmT ≤ 1 + r '(x)+ r '(p) - r (x) - r '(p)

AmT ≤ 1 + r '(x) - r (x)

since r '(x) ≥ r (x)

AmT ≤ 1 +3( r '(x) - r (x))

Amortized Analysis

AcT = 2 (cost of double rotation) Pi = r '(x) + r '(p) + r '(g) Pi-1= r (x) + r (p) + r (g)

AmT = AcT + (Pi – Pi-1 ) since only x, p and g can change rank AmT = 1 + r '(x)+ r '(p) - r (x) - r (p) since r '(x) = r (g) AmT = 2 + r '(x)+ r '(p) + r '(g) - r (x) - r (p) - r (g) AmT = 2 + r '(p) + r '(g) - r (x) - r (p)

since r (x) ≤ r (p) AmT ≤ 2 + r '(p) + r '(g) - r (x) - r (x) AmT ≤ 2 + r '(p) + r '(g) - 2 r (x)

Amortized Analysis

NextBack

Since r '(x) ≥ r '(p)

AmT ≤ 2 + r '(x) + r '(g) - 2 r (x) —— (1) from figure s (x) + s '(g) ≤ s '(x) from lemma log s (x) + log s '(g) ≤ 2 log s '(x) -2 by definition of rank r (x) + r '(g) ≤ 2 r '(x) - 2

Putting the value in equation 1

AmT ≤ 2 + r '(x) + r '(g) – 2 r (x)

AmT ≤ 2 + r '(x) + r '(g) + r (x) – 3 r (x)

AmT ≤ 2 + r '(x) + ( 2 r '(x) - 2 ) – 2 r (x)

AmT ≤ 3( r '(x) - r (x) )

Amortized Analysis

AcT = 2 (cost of double rotation) Pi = r '(x) + r '(p) + r '(g) Pi-1= r (x) + r (p) + r (g)

AmT = AcT + (Pi – Pi-1 ) since only x, p and g can change rank AmT = 2 + r '(x)+ r '(p) + r '(g) - r (x) - r (p) - r (g)

since r '(x) = r (g) AmT = 2 + r '(x)+ r '(p) + r '(g) - r (x) - r (p) - r (g) AmT = 2 + r '(p) + r '(g) - r (x) - r (p)

since r (x) ≤ r (p) AmT ≤ 2 + r '(p) + r '(g) - r (x) - r (x) AmT ≤ 2 + r '(p) + r '(g) - 2 r (x) —— (1)

Amortized Analysis

Back Next

from figure s '(p) +s '(g) ≤ s '(x) from lemma log s '(p) + log s '(g) ≤ 2 log s '(x) -2 by definition of rank r '(p) + r '(g) ≤ 2 r '(x) - 2

Putting the value in equation 1

AmT ≤ 2 + r '(p) + r '(g) – 2 r (x)

AmT ≤ 2 + ( r '(x) - 2 ) – 2 r (x)

AmT ≤ 2( r '(x) - r (x) )

since 2( r '(x) - r (x) ) ≤ 3( r '(x) - r (x) )

AmT ≤ 3( r '(x) - r (x) )

Amortized Analysis

Splay Trees Advanced)

Documents