1. Dynamic Order Statistics
CS 332: Algorithms
Dynamic Order Statistics
David Luebke /26/2018

2. Review: Choosing A Hash Function
Choosing the hash function well is crucial
Bad hash function puts all elements in same slot
A good hash function:
Should distribute keys uniformly into slots
Should not depend on patterns in the data
We discussed three methods:
Division method
Multiplication method
Universal hashing
David Luebke /26/2018

3. Review: Universal Hashing
When attempting to foil an malicious adversary, randomize the algorithm
Universal hashing: pick a hash function randomly when the algorithm begins (not upon every insert!)
Guarantees good performance on average, no matter what keys adversary chooses
Need a family of hash functions to choose from
David Luebke /26/2018

4. Review: Universal Hashing
A family of hash functions  is said to be universal if:
With a random hash function from , the chance of a collision between x and y is exactly 1/m (x  y)
We can use this to get good expected performance:
Choose h from a universal family of hash functions
Hash n keys into a table of m slots, n  m
Then the expected number of collisions involving a particular key x is less than 1
David Luebke /26/2018

5. Review: A Universal Hash Function
Choose table size m to be prime
Decompose key x into r+1 bytes, so that x = {x0, x1, …, xr}
Only requirement is that max value of byte < m
Let a = {a0, a1, …, ar} denote a sequence of r+1 elements chosen randomly from {0, 1, …, m - 1}
Define corresponding hash function ha  :
With this definition,  has mr+1 members
David Luebke /26/2018

6. Review: A Universal Hash Function
 is a universal collection of hash functions (Theorem 12.4)
How to use:
Pick r based on m and the range of keys in U
Pick a hash function by (randomly) picking the a’s
Use that hash function on all keys
David Luebke /26/2018

7. Review: Order Statistic Trees
OS Trees augment red-black trees:
Associate a size field with each node in the tree
x->size records the size of subtree rooted at x, including x itself:
M 8
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
David Luebke /26/2018

8. How can we use this property to select the ith element of the set?
Selection On OS Trees
M 8
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
How can we use this property to select the ith element of the set?
David Luebke /26/2018

9. OS-Select OS-Select(x, i) { r = x->left->size + 1; if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
David Luebke /26/2018

10. OS-Select Example Example: show OS-Select(root, 5): OS-Select(x, i) {
r = x->left->size + 1;
if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
M 8
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
David Luebke /26/2018

11. OS-Select Example Example: show OS-Select(root, 5): OS-Select(x, i) {
r = x->left->size + 1;
if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
M 8
i = 5 r = 6
C 5
P 2
A 1
F 3
Q 1
D 1
H 1
David Luebke /26/2018

12. OS-Select Example Example: show OS-Select(root, 5): OS-Select(x, i) {
r = x->left->size + 1;
if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
M 8
i = 5 r = 6
C 5
i = 5 r = 2
P 2
A 1
F 3
Q 1
D 1
H 1
David Luebke /26/2018

13. OS-Select Example Example: show OS-Select(root, 5): OS-Select(x, i) {
r = x->left->size + 1;
if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
M 8
i = 5 r = 6
C 5
i = 5 r = 2
P 2
A 1
F 3
i = 3 r = 2
Q 1
D 1
H 1
David Luebke /26/2018

14. OS-Select Example Example: show OS-Select(root, 5): OS-Select(x, i) {
r = x->left->size + 1;
if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
M 8
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
i = 5 r = 6
i = 5 r = 2
i = 3 r = 2
i = 1 r = 1
David Luebke /26/2018

15. OS-Select: A Subtlety What happens at the leaves?
OS-Select(x, i) {
r = x->left->size + 1;
if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
What happens at the leaves?
How can we deal elegantly with this?
Oops…
David Luebke /26/2018

16. OS-Select What will be the running time? OS-Select(x, i) {
r = x->left->size + 1;
if (i == r)
return x;
else if (i < r)
return OS-Select(x->left, i);
else
return OS-Select(x->right, i-r); }
What will be the running time?
David Luebke /26/2018

17. Determining The Rank Of An Element
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
What is the rank of this element?
David Luebke /26/2018

18. Determining The Rank Of An Element
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
Of this one? Why?
David Luebke /26/2018

19. Determining The Rank Of An Element
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
Of the root? What’s the pattern here?
David Luebke /26/2018

20. Determining The Rank Of An Element
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
What about the rank of this element?
David Luebke /26/2018

21. Determining The Rank Of An Element
C 5
P 2
Q 1
A 1
F 3
D 1
H 1
This one? What’s the pattern here?
David Luebke /26/2018

22. OS-Rank What will be the running time? OS-Rank(T, x) {
r = x->left->size + 1;
y = x;
while (y != T->root)
if (y == y->p->right)
r = r + y->p->left->size + 1;
y = y->p;
return r; }
What will be the running time?
David Luebke /26/2018

23. OS-Trees: Maintaining Sizes
So we’ve shown that with subtree sizes, order statistic operations can be done in O(lg n) time
Next step: maintain sizes during Insert() and Delete() operations
How would we adjust the size fields during insertion on a plain binary search tree?
David Luebke /26/2018

24. OS-Trees: Maintaining Sizes
So we’ve shown that with subtree sizes, order statistic operations can be done in O(lg n) time
Next step: maintain sizes during Insert() and Delete() operations
How would we adjust the size fields during insertion on a plain binary search tree?
A: increment sizes of nodes traversed during search
David Luebke /26/2018

25. OS-Trees: Maintaining Sizes
So we’ve shown that with subtree sizes, order statistic operations can be done in O(lg n) time
Next step: maintain sizes during Insert() and Delete() operations
How would we adjust the size fields during insertion on a plain binary search tree?
A: increment sizes of nodes traversed during search
Why won’t this work on red-black trees?
David Luebke /26/2018

26. Maintaining Size Through Rotation
y 19
x 19
rightRotate(y)
x 11
y 12 7 6
leftRotate(x) 6 4 4 7
Salient point: rotation invalidates only x and y
Can recalculate their sizes in constant time
Why?
David Luebke /26/2018

27. Augmenting Data Structures: Methodology
Choose underlying data structure
E.g., red-black trees
Determine additional information to maintain
E.g., subtree sizes
Verify that information can be maintained for operations that modify the structure
E.g., Insert(), Delete() (don’t forget rotations!)
Develop new operations
E.g., OS-Rank(), OS-Select()
David Luebke /26/2018