Weight-balanced Binary Search Trees

Transcription

1 Weight-balanced Binary Search Trees Weight-balanced BSTs are one way to achieve O(lg n) tree height. A weight-balanced BST: is a binary search tree at every node v: Equivalently: ( weight means size+1) 1 3 size(v.left) + 1 size(v.right) size(v.left) + 1 (size(v.right) + 1) 3 (size(v.left) + 1) 3 size(v.right) / 21

2 Example & Counterexample balanced unbalanced 2 / 21

3 Rebalancing: Summary For each node v on the path from new/deleted node back to root: if (size(v.left) + 1) 3 < size(v.right) + 1 let x = v.right if size(x.left) + 1 < (size(x.right) + 1) 2 single-rotation ccw else double-rotation cw then ccw else if size(v.left) + 1 > (size(v.right) + 1) 3 let x = v.left if (size(x.left) + 1) 2 > size(x.right) + 1 single-rotation cw else double-rotation ccw then cw else no rotation 3 / 21

4 Rebalance (Right Side) Subcase 1 of 2 Single-Rotation CCW If (size(v.left) + 1) 3 < size(v.right) + 1: Let x = v.right If size(x.left) + 1 < (size(x.right) + 1) 2: v x R x v T S T R S Idea: T is big enough to be on par with R, v, and S combined. 4 / 21

5 Rebalance (Right Side) Subcase 1 of 2 Example / 21

6 Rebalance (Right Side) Subcase 2 of 2 Double-Rotation CW Then CCW If (size(v.left) + 1) 3 < size(v.right) + 1: Let x = v.right If size(x.left) + 1 (size(x.right) + 1) 2: Let w = x.left: v w R x v x w T R S 1 S 2 T S 1 S 2 Idea: S in the middle is too big. Split. 6 / 21

7 Rebalance (Right Side) Subcase 2 of 2 Example / 21

8 Rebalance (Left Side) Subcase 1 of 2 Single-Rotation CW If size(v.left) + 1 > (size(v.right) + 1) 3: Let x = v.left If (size(x.left) + 1) 2 > size(x.right) + 1: v x x R T v T S S R 8 / 21

9 Rebalance (Left Side) Subcase 2 of 2 Double-Rotation CCW Then CW If size(v.left) + 1 > (size(v.right) + 1) 3: Let x = v.left If (size(x.left) + 1) 2 size(x.right) + 1: Let w = x.right: v w x R x v T w T S 2 S 1 R S 2 S 1 9 / 21

10 Size Query And Update Cache size at each node: Each node has field num for known size of self. Query: size(v) = (v = null? 0 : v.num) Update: Set children s before parent s, so simply: v.num := 1 + size(v.left) + size(v.right) Update ancestors of new/deleted node, and nodes affected by rotations. 10 / 21

11 Summary of WBT Insertion Later we will see why WBT height is in O(lg n). With that in mind, WBT insertion: 1. find which node to become parent of new node [Θ(lg n) time] 2. put new node there [Θ(1) time] 3. from that parent to root (bottom-up): check and fix balance, update size [Θ(lg n) nodes, Θ(1) time per node] Total Θ(lg n) time. 11 / 21

12 Summary of WBT Deletion Next we will see why WBT height is O(lg n). 1. find which node has the key, call it w [Θ(lg n) time] 2. if at most one child, w.parent adopts that child [Θ(1) time] 3. else: 3.1 go to successor x [Θ(lg n) time] 3.2 w.key := x.key [Θ(1) time] 3.3 x.parent adopts x.right [Θ(1) time] 4. from adopter to root (bottom-up): check and fix balance, update size [Θ(lg n) time] 12 / 21

13 WBT Height height(t) c lg(size(t) + 1) where c = 1/ lg(4/3) 2.4. Induction on size: Basis: height(empty) = 0; c lg(size(empty) + 1) = 0. Induction step (sketch): W.l.o.g. assume the right subtree is higher than the left subtree. size(t.right) + 1 (size(t) + 1) 3/4 height(t) = 1 + height(t.right) 1 + c lg(size(t.right) + 1) 1 + c lg((size(t) + 1) 3/4) = 1 + c lg(3/4) + c lg((size(t) + 1) = c lg((size(t) + 1) balance I.H. 13 / 21

14 WBT Union Similar divide-and-conquer union algorithm as AVL tree s. Change join(lt, k, Gt): If size(lt) + 1 > (size(gt) + 1) 3: joinright(lt, k, Gt) (Idea: k and Gt sneak under right spine of Lt.) If (size(lt) + 1) 3 < size(gt) + 1: joinleft(lt, k, Gt) (Idea: Lt and k sneak under left spine of Gt.) Else: Create new node, key is k, left child Lt, right child Gt. (This new node is balanced.) Next slide shows joinright. 14 / 21

15 joinright(lt, k, Gt) In Lt, traverse the right spine, find the node p such that p is still too big: size(p) + 1 > (size(gt) + 1) 3 but p.right is just right: size(p.right) + 1 (size(gt) + 1) 3 Create new node q, key is k, left child p.right, right child Gt. This node is balanced. (Why?) p s new right child is q. (k and Gt sneak under p.) p p q R S R k p and ancestors may need rebalancing. S Gt 15 / 21

16 Ranking In a set or a dictionary: Rank of key k is i iff k is the ith smallest key. Example: if s stores these keys 42, 55, 61, then: s.rank(42) returns 1 s.rank(55) returns 2 s.rank(61) returns 3 s.rank(k) throws exception if k not found If s is a binary search tree, can you do it in O(height) time? (Not good enough: at each node, store its rank.) 16 / 21

17 Ranks from Sizes: Introduction Recall: In WBT, each node caches size of subtree. In AVL tree, you can add the same caching. This will be useful for computing ranks. 17 / 21

18 Computing Ranks from Sizes, Part 1/3 (upper-right corners show sizes) v 6 50 v.left 2 3 v.right Rank of 50 is... 3 because there are 2 keys smaller than 50: those in the left subtree. Rank is size(v.left) + 1 Except... this may be just part of a larger tree. 18 / 21

19 Computing Ranks from Sizes, Part 2/3 If v has a parent: u 60 u 40 v 50 u.right 7 v u.left 50 v.left 2 v.right v.left 2 v.right Rank of 50 is 3. Rank of 50 is Except... u also has a parent, etc., ad infinitum. We need to loop or recurse over this. 19 / 21

20 Computing Ranks from Sizes, Part 3/3 Recursively: private static int relativerank(k k, Node <K> u) throws NotFound { if (u == null) { throw new NotFound(); } int c = k. compareto(u. key); if (c < 0) { return relativerank(k, u. left); } if (c > 0) { return size(u. left) relativerank(k, u. right); } return size(u. left) + 1; } public int rank(k k) throws NotFound { return relativerank(k, root); } 20 / 21

21 Computing Ranks from Sizes, Part 3/3 Iteratively: Keep a count on the number of smaller keys seen so far. int numsmaller = 0; Node <K> u = root; while (u!= null) { int c = k. compareto(u. key); if (c == 0) { return numsmaller + size(u. left) + 1; } else if (c > 0) { numsmaller += size(u. left) + 1; u = u. right; } else { // no change to numsmaller u = u. left; } throw new NotFound(); 20 / 21

22 The ith Smallest Key, from Sizes To find the ith key in: v 6 50 v.left 2 3 v.right If i > size(v): None. If i size(v.left): Go to v.left, find the ith key. If i = size(v.left) + 1: Found, v.key. Else: Go to v.right, find the (i size(v.left) 1)th key. 21 / 21