8: Splay Trees. Move-to-Front Heuristic. Splaying. Splay(12) CSE326 Spring April 16, Search for Pebbles: Move found item to front of list

Transcription

1 : Splay Trees SE Spring 00 pril, 00 Move-to-Front Heuristic Search for ebbles: Fred Wilma ebbles ino Fred Wilma ino ebbles Move found item to front of list Frequently searched items will move to start of list Effective both theoretically and practically Splaying Splay() 0 0 Move-To-Front for Trees

2 Gettin own: Step Splay() 0 emember the path to the node Know Who egot You Splay() Grandparent 0 arent Look at arent and Grandparent Splay ase Splay() otate Left, otate Left 0

3 Splay ase Splay() otate Left, otate Left Splay ase Splay() 0 0 otate Left Splay ases ase I ase II ase III

4 ll ressed Up Splay(k) Splay k, or predecessor or successor to k, to root, depending if k is in the tree. Insert(k) Splay(k), then update J J k J X X X elete(k) Splay(k), if root is k, then remove it, and oncat(, ) k X k X X X oncatenation Splay(+, T ) T T T T T T T < T oncat(t, T ): Splay(+, T ), then join T as right child of T. 0 Example } {{ } splay

5 Generalize the Example n n 0 splay(0) +0 n n n n n n mortized nalysis Splaying is the expensive operation Sometimes we do more than O(log n) work per node... Sometimes we do less than O(log n) work per node... ut it balances out: m operations in a tree with at most n nodes takes O(m log n) time! Easy to say, harder to prove Worst-ase nalysis Time = Money log n + We proved we needed to spend at most log n + time per VL insertion

6 Worst-ase nalysis log n + If the insertion was easy, our analysis loses mortized nalysis log n + If the splay was easy, bank the left-over money mortized nalysis log n + If the splay was hard, use money from the bank

7 mortized nalysis lways invest log n + per splay rove there s always enough money in the bank for any operation Then O(m log n) time to do m operations Store Money in the Tree u v r(v) dollars r(u) dollars r(v) = log size of subtree at v anks are Logarithms nodes ank of parent at least that of any child, but sometimes not greater. nodes 0

8 anks are Logarithms If both children have same rank, than rank of parent is larger rank = x rank = x The Money Invariant v v Each node v has r(v) dollars If v moves up, add more money to v r (v) > r(v) v v If v moves down, take money from v r (v) < r(v) The ost of Splaying: I lways the last step Only ranks of and change r ( ) = r() Get r( ) dollars Need r () r ( ) dollars Need to do the rotation Total: r ( ) r( ) +

9 The ost of Splaying: II Need r () + r () (r( ) + r()) (r ( ) r( )) If r ( ) > r( ), then (r ( ) r( )) is enough to pay for the rotation, too Otherwise, r ( ) = r( ), so do we need to pay for the rotation? The ost of Splaying If we pay for each case II, could pay Θ(n), and we need O(log n) If cost only depends on rank difference, we ll be okay: (r () ( ) r( )) + (r () ( ) r () ( )) + (r () ( ) r () ( )). + (r (k) ( ) r (k ) ( ))+ = (r (k) ( ) r( )) + log n + The ost of Splaying: II If r ( ) = r( ), then r () < r( ) Otherwise r ( ) > r( ) r () r ( ) = r( ) r() s s, with extra to pay for rotation

10 The ost of Splaying: III + s new s stays put (may waste some) s new, and pay r ( ) r( ) extra s If r ( ) > r( ), we re within (r ( ) r( ) after paying for rotation If r ( ) = r( ), then r ( ) = r( ) = r() = r() Hence r () < r ( ) or r () < r ( ), otherwise r ( ) > r( ) So r () < r() or r () < r( ), and can use extra to pay for rotation So What oes It ll Mean? If we perform m operations an have at most n nodes: ny Splay(K) needs at most log n + to maintain money invariant ny lookup or delete performs at most splays: at most ( log n + ) ny insert performs splay, plus money for the new root: at most ( log n ) O(m log n) dollars total needed matches VL trees!