1 / 27

CSE 326 Splay Trees

Learn about the efficient Splay Trees that offer amortized O(log n) time complexity. Explore splaying operations for find, delete, and insert and how they self-adjust.

annejohnson
Download Presentation

CSE 326 Splay Trees

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CSE 326Splay Trees David Kaplan Dept of Computer Science & Engineering Autumn 2001

  2. 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 node to the root! CSE 326 Autumn 2001 2

  3. Since you’re down there anyway, fix up a lot of deep nodes! Splay Tree Idea 10 You’re forced to make a really deep access: 17 5 2 9 3 CSE 326 Autumn 2001 3

  4. Splaying Cases 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 CSE 326 Autumn 2001 4

  5. Access root:Do nothing (that was easy!) root root n n X Y X Y CSE 326 Autumn 2001 5

  6. Access child of root:Zig (AVL single rotation) root root p n n Z X p X Y Y Z CSE 326 Autumn 2001 6

  7. Access (LR, RL) grandchild:Zig-Zag (AVL double rotation) g n X p g p n W X Y Z W Y Z CSE 326 Autumn 2001 7

  8. Access (LL, RR) grandchild:Zig-Zig Rotate top-down – why? g n W p p Z X n g Y Y Z W X CSE 326 Autumn 2001 8

  9. 6 5 4 Splaying Example:Find(6) 1 1 2 2 zig-zig 3 3 Find(6) 4 5 6 CSE 326 Autumn 2001 9

  10. 6 5 4 … still splaying … 1 1 2 6 zig-zig 3 3 2 5 4 CSE 326 Autumn 2001 10

  11. 6 1 … 6 splayed out! 1 6 zig 3 3 2 5 2 5 4 4 CSE 326 Autumn 2001 11

  12. 6 6 1 1 Splay it Again, Sam!Find (4) zig-zag 3 4 Find(4) 2 5 3 5 4 2 CSE 326 Autumn 2001 12

  13. 6 1 … 4 splayed out! 4 1 6 zig-zag 3 5 4 2 3 5 2 CSE 326 Autumn 2001 13

  14. Why Splaying Helps • 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. (Maybe not now, but soon, and for the rest of the operations.) CSE 326 Autumn 2001 14

  15. Splay Operations: Find • Find the node in normal BST manner • Splay the node to the root CSE 326 Autumn 2001 15

  16. Splay Operations: Insert • Ideas? • Can we just do BST insert? CSE 326 Autumn 2001 16

  17. Digression: Splitting • Split(T, x) creates two BSTs L and R: • all elements of T are in either L or R (T = L  R) • all elements in L are  x • all elements in R are  x • L and R share no elements (L  R = ) CSE 326 Autumn 2001 17

  18. Splitting in Splay Trees How can we split? • We have the splay operation. • We can find x or the parent of where x should be. • We can splay it to the root. • Now, what’s true about the left subtree of the root? • And the right? CSE 326 Autumn 2001 18

  19. Split split(x) splay T L R OR L R L R •  x > x < x •  x CSE 326 Autumn 2001 19

  20. split(x) L R Back to Insert void insert(Node *& root, Object x) { Node * left, * right; split(root, left, right, x); root = new Node(x, left, right); } x L R < x > x CSE 326 Autumn 2001 20

  21. find(x) L R Splay Operations: Delete x delete x L R < x > x Now what? CSE 326 Autumn 2001 21

  22. splay L R R Join Join(L, R): given two trees such that L < R, merge them Splay on the maximum element in L, then attach R L CSE 326 Autumn 2001 22

  23. find(x) L R Delete Completed x T delete x L R < x > x Join(L,R) T - x CSE 326 Autumn 2001 23

  24. Insert Example 4 4 6 6 split(5) 1 6 1 9 1 9 9 2 2 7 4 7 7 5 2 4 6 Insert(5) 1 9 2 7 CSE 326 Autumn 2001 24

  25. Delete Example 4 6 6 1 6 1 9 1 9 find(4) 9 2 2 7 4 7 Find max 7 2 2 2 1 6 1 6 Delete(4) 9 9 7 7 CSE 326 Autumn 2001 25

  26. Splay Tree Summary Can be shown that any M consecutive operations starting from an empty tree take at most O(M log(N))  All splay tree operations run in amortized O(log n) time O(N) operations can occur, but splaying makes them infrequent Implements most-recently used (MRU) logic • Splay tree structure is self-tuning CSE 326 Autumn 2001 26

  27. Splay Tree Summary (cont.) Splaying can be done top-down; better because: • only one pass • no recursion or parent pointers necessary There are alternatives to split/insert and join/delete Splay trees are very effective search trees • relatively simple: no extra fields required • excellent locality properties: frequently accessed keys are cheap to find (near top of tree) infrequently accessed keys stay out of the way (near bottom of tree) CSE 326 Autumn 2001 27

More Related