Balanced Binary Search Trees. Victor Gao

Transcription

1 Balanced Binary Search Trees Victor Gao

2 OUTLINE Binary Heap Revisited BST Revisited Balanced Binary Search Trees Rotation Treap Splay Tree

3 BINARY HEAP: REVIEW A binary heap is a complete binary tree such that The key of a child is always less than or equal to that of its parent

4 BINARY HEAP: PERFORMANCE For a binary heap with n elements, the height of the heap (tree) is log(n) Major operations can be done in O(log(n)) time

5 BINARY SEARCH TREE: REVIEW A binary search tree is a binary tree with a key associated to each node such that The key of the left child is less than that of the parent The key of the right child is greater than that of the parent

6 BINARY SEARCH TREE: REVIEW Important property: In-order traversal gives you the keys in sorted order

7 BINARY SEARCH TREE: PERFORMANCE Time complexities: Insertion: O(h) Deletion: O(h) Search: O(h) where h is the height of the tree In the worst case that the elements are inserted in sorted order, the tree degenerates to a linked list, and the operations above run in linear time. (This is bad!) We need a way to prevent the tree from degenerating!

8 QUESTIONS SO FAR?

9 BALANCED BINARY SEARCH TREES We don't want the BST to degenerate The basic idea is to make the BST more *balanced*, so that the height of the tree is bounded in some way Also called self-balancing binary search trees There are many different BBSTs, such as AVL (covered in CS 225), Red-Black (used by std::set and std::map), Treap and Splay. We will only talk about Treap and Splay today

10 ROTATION Left and Right Rotation are two common operations used by almost all kinds of BBSTs Q Right Rotation P P C A Q Left Rotation A B B C

11 ROTATION A rotation swaps a node (called *pivot*) with its parent, while maintaining the relative order of the keys (BST structure) Q Right Rotation P P C A Q Left Rotation A B B C

12 ROTATION Left and right rotation are completely symmetric Q Right Rotation P P C A Q Left Rotation A B B C

13 RANDOMIZED BST As mentioned before, sorted data can be a disaster for the original BST Randomly shuffling the data solves the problem and give us a tree with expected height of O(log(n)) This is not always possible Online queries Mixed insertions / deletions / searches We must find another way to make the tree *randomized*!

14 TREAP Treap = Tree + Heap Each node has two fields instead of one: Key Priority (a random value generated during insertion) Keys follow the BST rules and Priorities follow the Heap rules 4, 10 2, 15 7, 20 5, 25 9, 30

15 TREAP: OPERATIONS Treap is still a BST, so the standard BST search still works When inserting or deleting an element from the Treap, we have to maintain both the BST & Heap properties This is done by doing rotations Rotation maintains the BST properties It allows us to swap a node with its parent

16 TREAP: INSERTION First insert the node like you would do on a normal BST, then fix the heap properties by popping the node up (similar to what you do in a heap, but using rotation instead) 6, 18 4, 10 2, 15 7, 20 5, 25 9, 30

17 TREAP: INSERTION 4, 10 2, 15 7, 20 5, 25 9, 30 standard BST insertion 6, 18

18 TREAP: INSERTION 4, 10 2, 15 7, 20 6, 18 9, 30 5, 25 left rotation (pivot: 6, 18)

19 TREAP: INSERTION 4, 10 2, 15 6, 18 7, 20 5, 25 9, 30 right rotation (pivot: 6, 18)

20 TREAP: DELETION Deletion is a little bit more complicated If the node to be deleted is a leaf, simply remove it If the node is not a leaf, change its priority to infinity, rotate it to a leaf position and then remove it 4, 10 delete 2, 15 7, 20 5, 25 9, 30

21 TREAP: DELETION which node should we swap 7, inf with? - 5, 25 or 9, 30? 4, 10 2, 15 7, inf 5, 25 9, 30

22 TREAP: DELETION 4, 10 2, 15 5, 25 7, inf right rotation (pivot: 5, 25) 9, 30 because we want to maintain the heap property (25 < 30)

23 TREAP: DELETION 4, 10 2, 15 5, 25 9, 30 7, inf left rotation (pivot: 9, 30)

24 TREAP: COMPLEXITY ANALYSIS Being a randomized binary search tree, Treap has an expected height of O(log(n)) Therefore the three major operations (Search, Insertion, Deletion) have an expected time complexity of O(log(n)) In addition, Treap also supports fast Union, Intersection and Set Difference

25 QUESTIONS SO FAR?

26 SPLAY Splay is another kind of balanced binary search tree The core idea is to move the most recently accessed node to the root position of the tree, which is called the *splay* operation, while maintaining the BST properties The splay operation is done through a series of rotations There are several cases to consider

27 SPLAY - CASE 1 - ZIG If the node x is already a child of the root, simply rotate x and it will be swapped with the root This can only be the last step of a splay operation R rotate x

28 SPLAY - CASE 2 - ZIG-ZIG In this case, x and its parent p are both left or right children, we first rotate p g p p x g x A A

29 SPLAY - CASE 2 - ZIG-ZIG Then rotate x x p x g A p g A

30 SPLAY - CASE 3 - ZIG-ZAG In this case, node x is a left child and its parent p is a right child, or vice versa, we first rotate x g g p x x p A A

31 SPLAY - CASE 3 - ZIG-ZAG Then rotate x again g x x p g p A A

32 SPLAY - SEARCH & INSERTION To search on a Splay Tree, first do the standard BST search Then splay the node you just found (if any) to the root position When inserting into a Splay Tree, first do the standard BST insertion Then splay the node inserted to the root position

33 SPLAY - DELETION Deletion on BBSTs are usually quite complicated. However, with the splay operation, deleting a node from a splay tree can done in a quite nice way which is easy to understand.

34 SPLAY - DELETION Let's say we want to delete a node x First splay x to the root Then we have two sub-trees: L & R x x L R

35 SPLAY - DELETION Delete x and we're left with two disconnected trees L & R Then we want to merge L & R so that they become one splay tree again x L R L R

36 SPLAY - DELETION Find the right most node t in L By the BST properties, t must be the biggest in L Splay t to the root, so that the rest of L becomes t's left child t L R L R t

37 SPLAY - DELETION Now since t is the biggest in L, t's right child must be empty Also by the BST properties, any node in R is greater than t We can just attach R as t's right child t t L R L R This is NOT the only way to delete a node!

38 SPLAY - ACCESSING AN INTERVAL Since the elements in a binary search tree are ordered, each subtree can be viewed as an interval For example, in this tree, the subtree rooted at y represents all elements greater than x, and the subtree T represents all elements less than y (and greater than x) x y This is particularly useful for Splay Trees, since we can use the splay operation to make any x and y parent and child, and access the interval between them! T

39 SPLAY - ACCESSING AN INTERVAL Suppose we want to access interval [x, y] Case 1: there exists x < x and y > y Splay x to the root position and then splay y and make it the child of the root The left subtree of y is the interval we want x y

40 SPLAY - ACCESSING AN INTERVAL Suppose we want to access interval [x, y] Case 2: there exists x < x but no y > y Splay x to the root position and then splay y and make it the child of the root The subtree rooted at y now contains all elements greater than x and this is exactly what we want x y

41 SPLAY - ACCESSING AN INTERVAL Suppose we want to access interval [x, y] Case 3: there exists y > y but no x < x Similar to the previous case, splay y to the root position and the left subtree of y is what we want y

42 SPLAY - ACCESSING AN INTERVAL Suppose we want to access interval [x, y] Case 4: there is no x' < x nor y' > y This means, x is the smallest element and y is the largest element and you are simply want the whole tree No rotations need to be done

43 SPLAY - COMPLEXITY ANALYSIS The analysis is complicated and we will not cover it today It is guaranteed in the worst case, each splay operation has amortized time complexity O(log(n)) Which means, if you perform m splays on a Splay Tree with n nodes, the worst case complexity would be O(m*log(n)) Since all other operations call splay a constant number of times, their time complexities are also O(log(n)) (amortized)

44 RECORDING ADDITIONAL INFORMATION By adding additional data fields to the nodes of a BBST, we can keep track of some additional information These fields need to be updated dynamically when rotations are performed For example, if we record and maintain the size of the subtree rooted at each node, we can find the k th largest number efficiently using binary search on the tree Similar to segment trees, lazy flags can also be used here to boost certain operations, like reversing all elements in a given range of an array (using a Splay Tree)

45 WRAP UP We reviewed Binary Heap and Binary Search Tree We learned about Rotation and how it maintained the BST property We then learned two Balanced Binary Search Tree structures, Treap and Splay, which introduced additional properties to limit the height. These additional properties are maintained through rotations.

46 QUESTIONS?