Splay Trees. Splay Trees. Splay Trees. Splay Trees

Transcription

1 Slay Trees Slay Trees isadvantae of balanced search trees: worst case; no advantae for easy inuts additional memory required comlicated imlementation Slay Trees: + after access, an element is moved to the root; slay() reeated accesses are faster find() search for accordin to a search tree let be last element on search-ath slay( ) only amortized uarantee read-oerations chane the tree Ernst Mayr, Harald Räcke 16 Ernst Mayr, Harald Räcke 163 Slay Trees Slay Trees insert() search for ; is last visited element durin search (successer or redecessor of ) slay( ) moves to the root insert as new root delete() search for ; slay(); remove search larest element in slay( ) (on subtree ) connect root of as riht child of The illustration shows the case when is the redecessor of. Ernst Mayr, Harald Räcke 164 Ernst Mayr, Harald Räcke 165

2 Move to Root Slay: Zi ase How to brin element to root? one (bad) otion: movetoroot() iteratively do rotation around arent of until is root better otion slay(): zi case: if is child of root do left rotation or riht rotation around arent if is left child do riht rotation otw. left rotation Note that movetoroot() does the same. Ernst Mayr, Harald Räcke 166 Ernst Mayr, Harald Räcke 167 Slay: Ziza ase ouble Rotations z better otion slay(): LeftRotate(y) y RihtRotate() ziza case: if is riht child and arent of is left child z (or left child arent of riht child) y y do double riht rotation around rand-arent (res. double left rotation) z oublerihtrotate() Note that movetoroot() does the same. Ernst Mayr, Harald Räcke 168

3 Slay: Zizi ase This case is different between movetoroot() and slay(). Slay vs. Move to Root a b H e d E c F G better otion slay(): zizi case: if is left child and arent of is left child (or f riht child, arent of riht child) do riht roation around rand-arent followed by riht rotation around arent (res. left rotations) Inut tree on which slay() and movetoroot() is eecuted. Ernst Mayr, Harald Räcke 170 Ernst Mayr, Harald Räcke 171 Slay vs. Move to Root Slay vs. Move to Root a b b H d a c G f c G H e d E F e E F f Result after movetoroot(). Result after slay(). Ernst Mayr, Harald Räcke 171 Ernst Mayr, Harald Räcke 17

4 Static Otimality ynamic Otimality Suose we have a sequence of m find-oerations. find() aears h times in this sequence. The cost of a static search tree T is: Let S be a sequence with m find-oerations. Let be a data-structure based on a search tree: the cost for accessin element is 1 + deth(); cost(t ) = m + h deth T () after accessin the tree may be re-arraned throuh rotations; The total cost for rocessin the sequence on a slay-tree is O(cost(T min )), where T min is an otimal static search tree. onjecture: slay tree that only contains elements from S has cost O(cost(, S)), for rocessin S. deth T () is the number of edes on a ath from the root of T to. Theorem iven without roof. Ernst Mayr, Harald Räcke 173 Ernst Mayr, Harald Räcke 174 mortized nalysis Lemma 1 Slay Trees have an amortized runnin time of O(lo n) for all oerations. efinition data structure with oerations o 1 (),..., o k () has amortized runnin times t 1,..., t k for these oerations if the followin holds. Suose you are iven a sequence of oerations (startin with an emty data-structure) that oerate on at most n elements, and let k i denote the number of occurences of o i () within this sequence. Then the actual runnin time must be at most i k i t i (n). Ernst Mayr, Harald Räcke 175 Ernst Mayr, Harald Räcke 176

5 Potential Method Introduce a otential for the data structure. Φ( i ) is the otential after the i-th oeration. mortized cost of the i-th oeration is Show that Φ( i ) Φ( 0 ). Then k c i i=1 ĉ i = c i + Φ( i ) Φ( i 1 ). k c i + Φ( k ) Φ( 0 ) = i=1 This means the amortized costs can be used to derive a bound on the total cost. k i=1 ĉ i Eamle: Stack Stack S. ush() S. o() S. multio(k): removes k items from the stack. If the stack currently contains less than k items it emties the stack. The user has to ensure that o and multio do not enerate an underflow. ctual cost: S. ush(): cost 1. S. o(): cost 1. S. multio(k): cost min{size, k} = k. Ernst Mayr, Harald Räcke 177 Ernst Mayr, Harald Räcke 178 Eamle: Stack Use otential function Φ(S) = number of elements on the stack. mortized cost: S. ush(): cost S. o(): cost Ĉ ush = ush + Φ = Ĉ o = o + Φ = S. multio(k): cost Note that the analysis becomes wron if o() or multio() are called on an emty stack. Ĉ m = m + Φ = min{size, k} min{size, k} 0. Eamle: inary ounter Incrementin a binary counter: onsider a comutational model where each bit-oeration costs one time-unit. Incrementin an n-bit binary counter may require to eamine n-bits, and maybe chane them. ctual cost: hanin bit from 0 to 1: cost 1. hanin bit from 1 to 0: cost 1. Increment: cost is k + 1, where k is the number of consecutive ones in the least sinificant bit-ositions (e., has k = 1). Ernst Mayr, Harald Räcke 179 Ernst Mayr, Harald Räcke 180

6 Eamle: inary ounter hoose otential function Φ() = k, where k denotes the number of ones in the binary reresentation of. mortized cost: hanin bit from 0 to 1: Ĉ 0 1 = Φ = Slay Trees otential function for slay trees: size s() = T rank r() = lo (s()) Φ(T ) = v T r (v) hanin bit from 1 to 0: amortized cost = real cost + otential chane Ĉ 1 0 = Φ = Increment: Let k denotes the number of consecutive ones in the least sinificant bit-ositions. n increment involves k (1 0)-oerations, and one (0 1)-oeration. The cost is essentially the cost of the slay-oeration, which is 1 lus the number of rotations. Hence, the amortized cost is kĉ Ĉ 0 1. Ernst Mayr, Harald Räcke 18 Slay: Zi ase Slay: Zizi ase Last inequality follows from net slide. Φ = r () + r () r () r () = r () r () r () r () cost zi 1 + 3(r () r ()) Φ = r () + r () + r () r () r () r () = r () + r () r () r () r () + r () r () r () = r () + r () + r () 3r () + 3r () r () r () = r () + r () + r () + 3(r () r ()) Ernst Mayr, Harald Räcke (r () r ()) cost zizi 3(r () r ())

7 Slay: Zizi ase The last inequality holds because lo is a concave function. Slay: Ziza ase 1( ) r () + r () r () = 1 ( ) lo(s()) + lo(s ()) lo(s ()) = 1 ( s() ) lo + 1 ( s lo () ) ( 1 lo s () s () s() s () + 1 s () ) ( 1 s lo = 1 () ) Φ = r () + r () + r () r () r () r () = r () + r () r () r () r () + r () r () r () = r () + r () r () + r () r () + (r () r ()) cost ziza 3(r () r ()) Ernst Mayr, Harald Räcke 185 Slay: Ziza ase 1( ) r () + r () r () = 1 ( ) lo(s ()) + lo(s ()) lo(s ()) ( 1 s () lo s () + 1 s () ) ( 1 s lo = 1 () ) mortized cost of the whole slay oeration: stes t = + r (root) r 0 () O(lo n) 3(r t () r t 1 ()) The first one is added due to the fact that so far for each ste of a slay-oeration we have only counted the number of rotations, but the cost is 1+#rotations. The second one comes from the zi-oeration. Note that we have at most one zi-oeration durin a slay. Ernst Mayr, Harald Räcke 185 Ernst Mayr, Harald Räcke 186

8 Slay Trees ibliorahy?????????????????????????????????????? Ernst Mayr, Harald Räcke 187