Ranking. In an ordered 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:

Transcription

1 Ranking In an ordered 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(7) reports 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. Why?) 1 / 16

2 Ranks from Sizes: Introduction In AVL tree, add a num field to each node to cache size of subtree (starting from that node and downwards). In weight-balanced tree, each node already has it for re-balancing. Can use size(v) = (v = null? 0 : v.num). This will help compute ranks. How to update num s during insert and delete in O(lg n) time: New node has initial num := 1. Nodes that have left and/or right changed need updates: Ancestors of new/lost node; nodes changed during rotations. O(lg n) of them. Order: From bottom to top, so the following works: u.num := 1 + size(u.left) + size(u.right). O(1) time. 2 / 16

3 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. 3 / 16

4 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. 4 / 16

5 Computing Ranks from Sizes, Part 3/3 Recursively rank(k) = relativerank(k, root) relativerank(k, u) = if u = null: Not found if k < u.key: relativerank(k, u.left) if k > u.key: size(u.left) relativerank(k, u.right) else: size(u.left) + 1 Obviously O(height) time. 5 / 16

6 Computing Ranks from Sizes, Part 3/3 Iteratively Keep a count on the number of smaller keys known so far. numsmaller := 0 u := root while u null: if k < u.key: u := u.left else if k > u.key: numsmaller := numsmaller + size(u.left) + 1 u := u.right else: return numsmaller + size(u.left) + 1 report Not found Obviously O(height) time. 6 / 16

7 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): Not found. 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. 7 / 16

8 Set of Intervals Store a set of closed intervals and support querying by overlap. (Imagine: On-duty times of Math Aid Room TAs.) Closed interval: {r R l r h} = [l, h]. Representation: Just store l and h. Operations: insert(l, h): Store [l, h] in the collection. delete(l, h): Delete [l, h]. (And instead of normal lookup, we have:) search(l, h): Return a stored interval that overlaps with [l, h]. (Imagine: Find an on-duty time that overlaps with your presence.) Want O(lg n) time each. 8 / 16

9 How to Test for Overlaps [l, h] and [lo, hi] overlap iff... hard to figure out. [l, h] and [lo, hi] do not overlap iff they look like: [l, h] [lo, hi] or [lo, hi] [l, h] iff h < lo or hi < l. Overlap iff lo h and l hi. (De Morgan s law!) 9 / 16

10 Interval Tree Use a binary search tree (AVL or WBT or... ) to store the intervals. For BST order, how to compare [l, h] with [l, h ]: If l < l, then [l, h] < [l, h ]. If l = l and h < h, then [l, h] < [l, h ]. Each node stores: lo and hi: interval s two ends max: Max of all hi s in the whole subtree. This helps searching for an overlapper. 10 / 16

11 Example (from textbook) 11 / 16

12 How to Update max Fields Updating max s during insert and delete: Similar to updating sizes and heights. New node has initial max := hi. Nodes that have left and/or right changed need updates: Ancestors of new/lost node; nodes changed during rotations. O(lg n) of them. Order: From bottom to top, so the following works: u.max = max(u.hi, u.left.max, u.right.max) (if the operands exist; if not, exercise for you) O(1) time. This stays within O(lg n) time. 12 / 16

13 search(l, h) Start with root. Say x is the current node pointer. If x = null: Not found. If x s interval overlaps with [l, h]: Found. If not: If x.left = null: Go right. Else if x.left.max < l: No possibility on left. Go right. Else l x.left.max: Go left. (Why is this prudent? Next slide.) Walks just one path. O(lg n) time. 13 / 16

14 search(l, h) When l x.left.max: [l, h] overlaps with someone in the left subtree, or none in the whole tree at all. So you lose nothing by going left. Proof: If no overlap in the left subtree: Let v be a node in the left subtree with v.hi = x.left.max. So v does not overlap with [l, h]. So h < v.lo or v.hi < l. v.hi < l because l x.left.max = v.hi. For every node z in the rest (x and right subtree): h < v.lo z.lo because BST order. So [l, h] does not overlap with z s interval. 14 / 16

15 Exercises 1. Will this alternative work? (When x s interval does not overlap with [l, h].) If x.right = null, go left. Else if l x.right.max, go right. Else go left. 2. Will this alternative work? (When x null.) If x.left null and l x.left.max: Go left. Else if x s interval overlaps with [l, h]: Found. Else: Go right. 15 / 16

16 Augmenting AVL/WBT Generally If you add a field f to each node to help with a new operation/query, how to update during insert and delete in O(lg n)-time? Sufficient condition: You have a O(1)-time formula to recompute x.f from fields of x.left, fields of x.right, and other fields of x itself. (Examples you have seen: size, height, max of hi s.) Proof sketch: In insert and delete, only O(lg n) nodes have left and/or right changed and need f recomputed: ancestors of new/lost node and nodes changed by rotations. Each O(1) time to recompute by going from bottom to top. (Also true of other rotation-based rebalancing schemes. Similar to textbook Theorem 14.1.) 16 / 16