CS : Data Structures

Transcription

1 CS : Data Structures Michael Schatz Nov 7, 2016 Lecture 28: HashTables

2 Assignment 8: Due Thursday Nov 10pm Remember: javac Xlint:all & checkstyle *.java & JUnit Solutions should be independently written!

3 Part 1: AVL Trees

4 Binary Search Tree k <k >k A BST is a binary tree with a special ordering property: If a node has value k, then the left child (and its descendants) will have values smaller than k; and the right child (and its descendants) will have values greater than k

5 Tree Rotations right-rotation(b) left-rotation(a) B A A B <A <B >A <B >A >B <A <B >A <B >A >B Note: Rotating a BST maintains the BST condition! Green < A < Brown < B < Purple

6 Complete Example Insert these values: ins(5) ins(2) 4 4 \ 5 ins(7) 4 \ 5 \ 7 5 / \ 4 7 l(4) ins(1) 5 / \ 4 7 / 2 5 / \ 4 7 / 2 / 1 Note: AVL Violations are fixed bottom up r(4) 5 / \ 2 7 / \ 1 4 ins(3) l(2) 5 / \ 2 7 / \ 1 4 / 3 5 / \ 4 7 / 2 / \ / \ 2 5 / \ \ r(5)

7 Removing 6 / \ 3 8 / \ / \ / \ / \ / \ \ / \ / \ 3 9 / 1 or 9 / 3 / \ 1 4 Remove leaf is easy Remove with only one child Is easy Remove Internal Node: Swap with predecessor /successor Remove from AVL just like removing from regular BST: Find successor Swap with that element, Remove the node that you just swapped. Make sure to update the height fields, and rebalance if necessary

8 Implementation Notes Rotations can be applied in constant time! Inserting a node into an AVL tree requires O(lg n) time and guarantees O(lg(n)) height Track the height of each node as a separate field The alternative is to track when the tree is lopsided, but just as hard and more error prone Don t recompute the heights from scratch, it is easy to compute but requires O(n) time! Since we are guaranteeing the tree will have height lg(n), just use an integer Only update the affected nodes Check out Appendix B for some very useful tips on hacking AVL trees!

9 AVL Tree Balance By construction, an AVL tree can never become too unbalanced AVL condition ensures left and right children differ by at most 1 But they arent necessarily full n=1 n=2 n=3 n=4 n=5 n=6 n=7

10 Sparse AVL Trees How many nodes are in the sparsest AVL tree of height h Sparse means fewest nodes with height h Does it still include an exponential number of nodes? S 1 S 2 S 3 S 4 S 5 h=1 n=1 h=2 n=2 h=3 n=4 h=4 n=7 h=5 n=12

11 Sparse AVL Trees How many nodes are in the sparsest AVL tree of height h Sparse means fewest nodes with height h Does it still include an exponential number of nodes? S 1 S 2 S 3 S 4 S 5 h=1 n=1 h=2 n=2 h=3 n=4 h=4 n=7 h=5 n=12 S 1 = 1 S 2 = 2 S 3 = S 2 + S S 4 = S 3 + S S 5 = S 4 + S S h = S h-1 + S h-2 + 1

12 Fibonacci Sequence public static int fib(int n) { if (n <= 1) { return 1; } return fib(n-1) + fib(n-2); } F(6) f(5) f(4) f(4) f(3) f(3) f(2) f(3) f(2) f(2) f(1) f(2) f(1) f(1) f(0) f(2) f(1) f(1) f(0) f(1) f(0) f(1) f(0) f(1) f(0)

13 Nodes in an AVL Tree How many nodes are in the sparsest AVL tree of height h Sparse means fewest nodes with height h Does it still include an exponential number of nodes? S(h) = F(h + 3) 1 Fibonacci grows exponentially at φ n AVL Trees grow exponentially at φ n -1 Therefore the height of any AVL tree is O(lg n)

14 Part 2: Treaps

15 BSTs versus Heaps p k p <k >k p p BST All keys in left subtree of k are < k, all keys in right are >k Tricky to balance, but fast to find Heap All children of the node with priority p have priority p Easy to balance, but hard to find (except min/max)

16 BSTs versus Heaps p k p <k >k p p BST All keys in left subtree of k are < k, all keys in right are >k Tricky to balance, but fast to find Heap All children of the node with priority p have priority p Easy to balance, but hard to find (except min/max)

17 Treap k/p <k /p >k /p A treap is a binary search tree where the nodes have both user specified keys (k) and internally assigned priorities (p). When inserting, use standard BST insertion algorithm, but then use rotations to iteratively move up the node while it has lower priority than its parent (analogous to a heap, but with rotations)

18 Treap Reflections Insert the following pairs: 7/1, 2/2, 1/3, 8/4, 3/5, 5/6, 4/7 7/1 / \ Since the priorities are in sorted order, becomes a standard BST and may have O(n) height 2/2 8/4 / \ 1/3 3/5 \ 5/6 / 4/7 Insert the following pairs: 7/3, 2/0, 1/7, 8/2, 3/9, 5/1, 4/7 With a standard BST, for 2 to be root it would have to be the first key inserted, and 5 would have to proceed all the other keys except 1, It is as if we saw the sequence: 2,5,8,7,1,4,3 Note priorities in sorted order: 2/0, 5/1, 8/2/, 7/3, 1/7, 4/7, 3/9 2/0 / \ 1/7 5/1 / \ 4/7 8/2 / / 3/9 7/3

19 What priorities should we assign to maintain a balanced tree? Math.random() Using random priorities essentially shuffles the input data (which might have bad linear height) into a random permutation that we expect to have O(log n) height J It is possible that we could randomly shuffle into a poor tree configuration, but that is extremely rare. In most practical applications, a treap will perform just fine, and will often outperform an AVL tree that guarantees O(log n) height but has higher constants

20 Random Tree Height ## Trying all permutations of 14 distinct keys numtrees: 87,178,291,200 average height: 6.63 maxheights[0]: % maxheights[1]: % maxheights[2]: % maxheights[3]: % maxheights[4]: % maxheights[5]: % maxheights[6]: % maxheights[7]: % maxheights[8]: % maxheights[9]: % maxheights[10]: % maxheights[11]: % maxheights[12]: % maxheights[13]: % maxheights[14]: %

21 Random Tree Height ## Trying all permutations of 15 distinct keys $ tail -f heights.15.log tree[ ]: maxheight: 6 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 9 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 7 tree[ ]: maxheight: 9 tree[ ]: maxheight: 8 tree[ ]: maxheight: 7

22 Self Balancing Trees Understanding the distinction between different kinds of balanced search trees: AVL trees guarantee worst case O(log n) operations by carefully accounting for the tree height splay trees guarantee amortized O(log n) operations by periodically applying a certain set of rotations (see lecture notes) treaps guarantee expected O(log n) operations by selecting a random permutation of the input data So if you have to play it safe and don t trust your random numbers, AVL trees are the way to go. If you can live with the occasional O(n) operation every now and then and you still don t trust your random numbers, splay trees are the way to go. And if you trust your random numbers, treaps are the way to go.

23 Part 3: Hash Tables

24 Maps aka dictionaries aka associative arrays Mike -> Malone 323 Peter -> Malone 223 Joanne -> Malone 225 Zack -> Malone 160 suite Debbie -> Malone 160 suite Yair -> Malone 160 suite Ron -> Garland 242 Key (of Type K) -> Value (of Type V) Note you can have multiple keys with the same value, But not okay to have one key map to more than 1 value

25 Maps, Sets, and Arrays Sets as Map<T, Boolean> Array as Map<Integer, T> Mike Peter Joanne Zack Debbie Yair Ron -> True -> True -> True -> True -> True -> True -> True 0 -> Mike 1 -> Peter 2 -> Joanne 3 -> Zack 4 -> Debbie 5 -> Yair 6 -> Ron Maps are extremely flexible and powerful, and therefore are extremely widely used Built into many common languages: Awk, Python, Perl, JavaScript Could we do everything in O(lg n) time or faster? => Balanced Search Trees

26 Maps, Sets, and Arrays Sets as Map<T, Boolean> Array as Map<Integer, T> Mike Peter Joanne Zack Debbie Yair Ron -> True -> True -> True -> True -> True -> True -> True 0 -> Mike 1 -> Peter 2 -> Joanne 3 -> Zack 4 -> Debbie 5 -> Yair 6 -> Ron Maps are extremely flexible and powerful, and therefore are extremely widely used Built into many common languages: Awk, Python, Perl, JavaScript Could we do everything in O(lg n) time or faster? => Balanced Search Trees

27 ADT: Arrays n-3 n-2 n-1 a: t t t t t t get(2) put(n-2, X) Fixed length data structure Constant time get() and put() methods Definitely needs to be generic J

28 Hashing Array[13] = 10; Array[42] = 15 O(1) Array[ Mike ] = 10; Array[ Peter ] = 15 BST:O(lg n) -> Hash:O(1) Hash Function enables: Map<K, V> -> Map<Integer, V> -> Array<V> h(): K -> Integer for any possible key K h() should distribute the keys uniformly over all integers if k 1 and k 2 are close, h(k 1 ) and h(k 2 ) should be far apart Typically want to return a small integer, so that we can use it as an index into an array An array with 4B cells in not very practical if we only expect a few thousand to a few million entries How do we restrict an arbitrary integer x into a value up to some maximum value n? 0 <= x % n < n Compression function: c(i) = abs(i) % length(a) Transforms from a large range of integers to a small range (to store in array a)

29 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a Peter insert(1, Peter ): c(h(1)) = c(1) = 1

30 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a Peter Paul Insert(20, Paul ): c(h(4)) = c(4) = 4

31 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a Peter Paul Mary insert(15, Mary ): c(h(15)) = c(15) = 7

32 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a Peter Paul Mary get(15): get(c(h(15))) = get(c(15)) = get(7) => Mary J

33 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a Peter Paul Mary has(4): has(c(h(4)) = has(c(4)) = has(4) => Paul L

34 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a Peter Paul Mary Beverly insert(4, Beverly ): c(h(4)) = c(4) = 4 L

35 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a Peter Paul Mary Two problems caused by collisions: False positives: How do we know the key is the one we want? Collision Resolution: What do we do when 2 keys map to same location?

36 Collisions Collisions occur when 2 different keys get mapped to the same value Within the hash function h(): Rare, the probability of 2 keys hashing to the same value is 1/4B. Within the compression function c(): Common, 4B integers -> n values Example: Hashing integers into an array with 8 cells h(i) = i c(i) = i % 8 a (1, Peter ) (20, Paul ) (15, Mary ) Two problems caused by collisions: False positives: How do we know the key is the one we want? Collision Resolution: What do we do when 2 keys map to same location?

37 Separate chaining Use Array<List<V>> instead of an Array<V> to store the entries a (1, Peter ) (20, Paul ) (15, Mary ) o o o insert(4, Beverly ): c(h(4)) = c(4) = 4

38 Separate chaining Use Array<List<V>> instead of an Array<V> to store the entries a (1, Peter ) (20, Paul ) (15, Mary ) o (4, Beverly ) o o insert(4, Beverly ): c(h(4)) = c(4) = 4

39 Separate chaining Use Array<List<V>> instead of an Array<V> to store the entries a (1, Peter ) (20, Paul ) (15, Mary ) o (4, Beverly ) o o Using separate chaining we could implement the Map<K,V> interface J Seems fast, but how fast do we expect it to be?

40 Separate Chaining Analysis Assume the table has just 1 cell: All n items will be in a linked list => O(n) insert/find/remove L Assume the hash function h() always returns a constant value All n items will be in a linked list => O(n) insert/find/remove L Assume table has m cells AND h() evenly distributes the keys Every cell is equally likely to be selected to store key k, so the n items should be evenly distributed across m slots Average number of items per slot: n/m Also called the load factor (commonly written as α) Also the probability of a collision when inserting a new key Empty table: 0/m probability After 1 st item: 1/m After 2 nd item: 2/m Expected time for unsuccessful search: Expected time for successful search: O(1+n/m) O(1+n/m/2) => O(1+n/m) If n < c*m, then we can expect constant time! J

41 Next Steps 1. Reflect on the magic and power of Hash Tables! 2. Assignment 8 due Thursday November 10pm

42 Welcome to CS Questions?