h ashing
play

H ASHING , S EARCH A PPLICATIONS Acknowledgement: The course slides - PowerPoint PPT Presentation

Sep 05, 2023 •201 likes •1.56k views

BBM 202 - ALGORITHMS D EPT . OF C OMPUTER E NGINEERING H ASHING , S EARCH A PPLICATIONS Acknowledgement: The course slides are adapted from the slides prepared by R. Sedgewick and K. Wayne of Princeton University.

  1. Separate chaining ST: Java implementation public class SeparateChainingHashST<Key, Value> 
 { 
 private int M = 97; // number of chains 
 private Node[] st = new Node[M]; // array of chains private static class Node { private Object key; private Object val; private Node next; ... } private int hash(Key key) 
 { return (key.hashCode() & 0x7fffffff) % M; } public void put(Key key, Value val) { int i = hash(key); for (Node x = st[i]; x != null; x = x.next) if (key.equals(x.key)) { x.val = val; return; } st[i] = new Node(key, val, st[i]); } } 19

  2. 
 
 
 
 
 
 
 Analysis of separate chaining Proposition. Under uniform hashing assumption, probability that the number of keys in a list is within a constant factor of N / M is extremely close to 1 . Pf sketch. Distribution of list size obeys a binomial distribution. (10, .12511...) .125 0 30 0 10 20 Binomial distribution ( N = 10 4 , M = 10 3 , � = 10) equals() and hashCode() Consequence. Number of probes for search/insert is proportional to N / M . • M too large ⇒ too many empty chains. • M too small ⇒ chains too long. M times faster than 
 sequential search • Typical choice: M ~ N / 5 ⇒ constant-time ops. 20

  3. ST implementations: summary worst-case cost average case key (after N inserts) (after N random inserts) ordered implementation interface 
 iteration? search insert delete search hit insert delete sequential search 
 N N N N/2 N N/2 no equals() (unordered list) binary search 
 lg N N N lg N N/2 N/2 yes compareTo() (ordered array) BST N N N 1.38 lg N 1.38 lg N ? yes compareTo() red-black tree 2 lg N 2 lg N 2 lg N 1.00 lg N 1.00 lg N 1.00 lg N yes compareTo() separate chaining N * N * N * 3-5 * 3-5 * 3-5 * no equals() * under uniform hashing assumption 21

  4. HASHING ‣ Hash functions ‣ Separate chaining ‣ Linear probing

  5. Collision resolution: open addressing Open addressing. [Amdahl-Boehme-Rocherster-Samuel, IBM 1953] 
 When a new key collides, find next empty slot, and put it there. st[0] jocularly null st[1] st[2] listen st[3] suburban null st[30000] browsing linear probing (M = 30001, N = 15000) 23

  6. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 st[] M = 16

  7. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. S insert hash(S) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 st[] M = 16

  8. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. S insert hash(S) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 st[] S M = 16

  9. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. S insert hash(S) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S st[] M = 16

  10. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S st[] M = 16

  11. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. E E insert hash(E) = 10 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S st[] M = 16

  12. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. E insert hash(E) = 10 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S st[] E M = 16

  13. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. E insert hash(E) = 10 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S E st[] M = 16

  14. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S E st[] M = 16

  15. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. A A insert hash(A) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S E st[] M = 16

  16. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. A insert hash(A) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 S E st[] A M = 16

  17. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. A insert hash(A) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E st[] M = 16

  18. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E st[] M = 16

  19. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. R R insert hash(R) = 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E st[] M = 16

  20. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. R insert hash(R) = 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E st[] R M = 16

  21. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. R insert hash(R) = 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E R st[] M = 16

  22. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E R st[] M = 16

  23. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. C C insert hash(C) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E R st[] M = 16

  24. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. C insert hash(C) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A S E R st[] C M = 16

  25. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. C insert hash(C) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S E R st[] M = 16

  26. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S E R st[] M = 16

  27. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. H H insert hash(H) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S E R st[] M = 16

  28. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. H insert hash(H) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S E R st[] H M = 16

  29. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. H insert hash(H) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S E R st[] H M = 16

  30. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. H insert hash(H) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S E R st[] H M = 16

  31. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. H insert hash(H) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S E R st[] H M = 16

  32. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. H insert hash(H) = 4 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R st[] M = 16

  33. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R st[] M = 16

  34. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. X X insert hash(X) = 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R st[] M = 16

  35. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. X insert hash(X) = 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R st[] X M = 16

  36. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. X insert hash(X) = 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R X st[] M = 16

  37. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R X st[] M = 16

  38. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. M M insert hash(M) = 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R X st[] M = 16

  39. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. M insert hash(M) = 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A C S H E R X st[] M M = 16

  40. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. M insert hash(M) = 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 M A C S H E R X st[] M = 16

  41. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 M A C S H E R X st[] M = 16

  42. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. P P insert hash(P) = 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 M A C S H E R X st[] M = 16

  43. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. P insert hash(P) = 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 M A C S H E R X st[] P M = 16

  44. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. P insert hash(P) = 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 M A C S H E R X st[] P P M = 16

  45. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. P insert hash(P) = 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H E R X st[] M = 16

  46. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H E R X st[] M = 16

  47. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. L L insert hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H E R X st[] M = 16

  48. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. L insert hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H E R X st[] L M = 16

  49. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. L insert hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H E R X st[] L M = 16

  50. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. L insert hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H E R X st[] L M = 16

  51. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. L insert hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  52. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  53. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  54. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. E search hash(E) = 10 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  55. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. E search hash(E) = 10 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] E M = 16 search hit (return corresponding value)

  56. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  57. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. L L search hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  58. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. L search hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] L M = 16

  59. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. L search hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] L M = 16

  60. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. L search hash(L) = 6 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] L M = 16 search hit (return corresponding value)

  61. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. linear probing hash table 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  62. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. K K search hash(K) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16

  63. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. K search hash(K) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] K M = 16

  64. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. K search hash(K) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] K M = 16

  65. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. K search hash(K) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] K M = 16

  66. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. K search hash(K) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] K M = 16

  67. Linear probing hash table Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. K search hash(K) = 5 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] K M = 16 search miss (return null)

  68. Linear probing - Summary Hash. Map key to integer i between 0 and M - 1 . Insert. Put at table index i if free; if not try i + 1, i + 2 , etc. Search. Search table index i ; if occupied but no match, try i + 1, i + 2 , etc. Note. Array size M must be greater than number of key-value pairs N. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 P M A C S H L E R X st[] M = 16 86

  69. Linear probing ST implementation public class LinearProbingHashST<Key, Value> { private int M = 30001; array doubling private Value[] vals = (Value[]) new Object[M]; and halving 
 private Key[] keys = (Key[]) new Object[M]; code omitted private int hash(Key key) { /* as before */ } public void put(Key key, Value val) { int i; for (i = hash(key); keys[i] != null; i = (i+1) % M) if (keys[i].equals(key)) break; keys[i] = key; vals[i] = val; } public Value get(Key key) { for (int i = hash(key); keys[i] != null; i = (i+1) % M) if (key.equals(keys[i])) return vals[i]; return null; } } 87

  70. Clustering Cluster. A contiguous block of items. Observation. New keys likely to hash into middle of big clusters. 88

  71. 
 
 
 
 
 
 
 
 Knuth's parking problem Model. Cars arrive at one-way street with M parking spaces. 
 Each desires a random space i : if space i is taken, try i + 1, i + 2, etc. 
 Q. What is mean displacement of a car? displacement = 3 Half-full. With M / 2 cars, mean displacement is ~ 3 / 2 . Full. With M cars, mean displacement is ~ π M / 8 89

  72. 
 
 
 
 
 
 
 Analysis of linear probing Proposition. Under uniform hashing assumption, the average number of probes in a linear probing hash table of size M that contains N = α M keys is: � ⇥ � ⇥ ∼ 1 1 ∼ 1 1 1 + 1 + 2 (1 − α ) 2 2 1 − α search hit search miss / insert Pf. Parameters. • M too large ⇒ too many empty array entries. • M too small ⇒ search time blows up. • Typical choice: α = N / M ~ ½ . # probes for search hit is about 3/2 # probes for search miss is about 5/2 90

  73. ST implementations: summary worst-case cost average case (after N inserts) (after N random inserts) ordered key implementation iteration? interface search insert delete search hit insert delete sequential search 
 N N N N/2 N N/2 no equals() (unordered list) binary search 
 lg N N N lg N N/2 N/2 yes compareTo() (ordered array) BST N N N 1.38 lg N 1.38 lg N ? yes compareTo() red-black tree 2 lg N 2 lg N 2 lg N 1.00 lg N 1.00 lg N 1.00 lg N yes compareTo() separate N * N * N * 3-5 * 3-5 * 3-5 * no equals() chaining linear probing N * N * N * 3-5 * 3-5 * 3-5 * no equals() * under uniform hashing assumption 91

  74. War story: String hashing in Java String hashCode() in Java 1.1. • For long strings: only examine 8-9 evenly spaced characters. • Benefit: saves time in performing arithmetic. public int hashCode() { int hash = 0; int skip = Math.max(1, length() / 8); for (int i = 0; i < length(); i += skip) hash = s[i] + (37 * hash); return hash; } • Downside: great potential for bad collision patterns. http://www.cs.princeton.edu/introcs/13loop/Hello.java http://www.cs.princeton.edu/introcs/13loop/Hello.class http://www.cs.princeton.edu/introcs/13loop/Hello.html http://www.cs.princeton.edu/introcs/12type/index.html 92

  75. 
 
 
 
 
 
 
 War story: algorithmic complexity attacks Q. Is the uniform hashing assumption important in practice? A. Obvious situations: aircraft control, nuclear reactor, pacemaker. A. Surprising situations: denial-of-service attacks. malicious adversary learns your hash function 
 (e.g., by reading Java API) and causes a big pile-up 
 in single slot that grinds performance to a halt Real-world exploits. [Crosby-Wallach 2003] • Bro server: send carefully chosen packets to DOS the server, 
 using less bandwidth than a dial-up modem. • Perl 5.8.0: insert carefully chosen strings into associative array. • Linux 2.4.20 kernel: save files with carefully chosen names. 93

  76. Algorithmic complexity attack on Java Goal. Find family of strings with the same hash code. Solution. The base 31 hash code is part of Java's string API. key hashCode() key hashCode() key hashCode() "Aa" 2112 "AaAaAaAa" -540425984 "BBAaAaAa" -540425984 "BB" 2112 "AaAaAaBB" -540425984 "BBAaAaBB" -540425984 "AaAaBBAa" -540425984 "BBAaBBAa" -540425984 "AaAaBBBB" -540425984 "BBAaBBBB" -540425984 "AaBBAaAa" -540425984 "BBBBAaAa" -540425984 "AaBBAaBB" -540425984 "BBBBAaBB" -540425984 "AaBBBBAa" -540425984 "BBBBBBAa" -540425984 "AaBBBBBB" -540425984 "BBBBBBBB" -540425984 2 N strings of length 2N that hash to same value! 94

  77. Diversion: one-way hash functions One-way hash function. "Hard" to find a key that will hash to a desired value (or two keys that hash to same value). Ex. MD4, MD5, SHA-0, SHA-1, SHA-2, WHIRLPOOL, RIPEMD-160, …. known to be insecure String password = args[0]; MessageDigest sha1 = MessageDigest.getInstance("SHA1"); byte[] bytes = sha1.digest(password); /* prints bytes as hex string */ Applications. Digital fingerprint, message digest, storing passwords. Caveat. Too expensive for use in ST implementations. 95

  78. Separate chaining vs. linear probing Separate chaining. • Easier to implement delete. • Performance degrades gracefully. • Clustering less sensitive to poorly-designed hash function. Linear probing. • Less wasted space. • Better cache performance. Q. How to delete? Q. How to resize? 96

  79. 
 
 
 Hashing: variations on the theme Many improved versions have been studied. Two-probe hashing. (separate-chaining variant) • Hash to two positions, insert key in shorter of the two chains. • Reduces expected length of the longest chain to log log N . Double hashing. (linear-probing variant) • Use linear probing, but skip a variable amount, not just 1 each time. • Effectively eliminates clustering. • Can allow table to become nearly full. • More difficult to implement delete. Cuckoo hashing. (linear-probing variant) • Hash key to two positions; insert key into either position; if occupied, 
 reinsert displaced key into its alternative position (and recur). • Constant worst case time for search. 97

  80. 
 
 Hash tables vs. balanced search trees Hash tables. • Simpler to code. • No effective alternative for unordered keys. • Faster for simple keys (a few arithmetic ops versus log N compares). • Better system support in Java for strings (e.g., cached hash code). Balanced search trees. • Stronger performance guarantee. • Support for ordered ST operations. • Easier to implement compareTo() correctly than equals() and hashCode() . Java system includes both. • Red-black BSTs: java.util.TreeMap , java.util.TreeSet . • Hash tables: java.util.HashMap , java.util.IdentityHashMap . 98

  81. TODAY ‣ Hashing ‣ Search applications

  82. S EARCH A PPLICATIONS 
 ‣ Sets ‣ Dictionary clients ‣ Indexing clients ‣ Sparse vectors 


Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

Recommend

e3511 SINGLE WAFER ASHING SYSTEM e3511 SINGLE WAFER ASHING SYSTEM Features PC / Controller

e3511 SINGLE WAFER ASHING SYSTEM e3511 SINGLE WAFER ASHING SYSTEM Features PC / Controller

e3511 SINGLE WAFER ASHING SYSTEM e3511 SINGLE WAFER ASHING SYSTEM Features PC / Controller Configuration Product Specification e3511 SINGLE WAFER ASHING SYSTEM Features True downstream mw plasma process uses a heated platen with temp up to

875 views • 10 slides
THE CR CRASH ASHING AN AND BUR URNING NG: Ho How F Far Do Do Y You GO GO? Professor

THE CR CRASH ASHING AN AND BUR URNING NG: Ho How F Far Do Do Y You GO GO? Professor

THE CR CRASH ASHING AN AND BUR URNING NG: Ho How F Far Do Do Y You GO GO? Professor Riyad Tarazi M.D ,F.A.C.S. Chief of the Cardiothoracic Surgery Department Head of Mechanical Circulatory Support and Transplantation Salman

583 views • 26 slides
H ASHING , S EARCH A PPLICATIONS Acknowledgement: The course slides are adapted from the slides

H ASHING , S EARCH A PPLICATIONS Acknowledgement: The course slides are adapted from the slides

BBM 202 - ALGORITHMS D EPT . OF C OMPUTER E NGINEERING H ASHING , S EARCH A PPLICATIONS Acknowledgement: The course slides are adapted from the slides prepared by R. Sedgewick and K. Wayne of Princeton University. TODAY Hashing

1.42k views • 141 slides
Purpose of the Meeting Provide I&amp;APs with information regarding: The proposed

Purpose of the Meeting Provide I&amp;APs with information regarding: The proposed

Environmental Impact Assessment (EIA) and Waste Licensing Application for the Proposed Continuous Ashing Activities at Majuba Power Station Pixley ka Seme Local Municipality Focus Group Meeting 20 November 2012 Purpose of the Meeting

591 views • 22 slides
Purpose of the Meeting Provide information regarding the project Provide an opportunity

Purpose of the Meeting Provide information regarding the project Provide an opportunity

Environmental Impact Assessment (EIA) and Waste Licensing Application for the Proposed Continuous Ashing Activities at Tutuka Power Station Public Meeting Standerton 22 November 2012 Purpose of the Meeting Provide information regarding

466 views • 18 slides
Ca Career eer an and T d T ec echn hnical ical Ed Educat ucation ion in in W Was

Ca Career eer an and T d T ec echn hnical ical Ed Educat ucation ion in in W Was

Ca Career eer an and T d T ec echn hnical ical Ed Educat ucation ion in in W Was ashing hington ton Rebecca Wallace, Executive Director Career and Technical Education Of Office ice of Superintende perintendent nt of Pu Publ

449 views • 13 slides
Dynamic Programming Ananth Grama, Anshul Gupta, George Karypis, and Vipin Kumar To accompany the

Dynamic Programming Ananth Grama, Anshul Gupta, George Karypis, and Vipin Kumar To accompany the

Dynamic Programming Ananth Grama, Anshul Gupta, George Karypis, and Vipin Kumar To accompany the text Introduction to Parallel Computing, Addison Wesley, 2003. Topic Overview Overview of Serial Dynamic Programming Serial Monadic DP

867 views • 42 slides
Identification of direct residue contacts in protein-protein interactions from multi-species

Identification of direct residue contacts in protein-protein interactions from multi-species

Identification of direct residue contacts in protein-protein interactions from multi-species sequence data Martin Weigt Institute for Scientific Interchange, Torino joint work with R.A. White, H. Szurmant, J.A. Hoch, T. Hwa [ MW et al, PNAS

316 views • 15 slides
Evaluation of in vitro mutagenicity assays Daniel Gerhard Institute of Biostatistics Leibniz

Evaluation of in vitro mutagenicity assays Daniel Gerhard Institute of Biostatistics Leibniz

Evaluation of in vitro mutagenicity assays Daniel Gerhard Institute of Biostatistics Leibniz University of Hannover Non Clinical Statistics Conference - 2008 D. Gerhard (LUH) Evaluation of in vitro mutagenicity assays NCS 2008 1 / 27

1.07k views • 27 slides
Bayesian Network Modelling in Genetics and Systems Biology Marco Scutari m.scutari@ucl.ac.uk

Bayesian Network Modelling in Genetics and Systems Biology Marco Scutari m.scutari@ucl.ac.uk

Bayesian Network Modelling in Genetics and Systems Biology Marco Scutari m.scutari@ucl.ac.uk Genetics Institute University College London October 15, 2013 Marco Scutari University College London Bayesian Networks: an Overview A Bayesian

800 views • 36 slides
practice Turin, September 13-14, 2018 Histopathological and Biological characterization of high

practice Turin, September 13-14, 2018 Histopathological and Biological characterization of high

Unmet challenges in high risk hematological malignancies: from benchside to clinical practice Turin, September 13-14, 2018 Histopathological and Biological characterization of high risk Hodgkin Lymphoma (CHL) Harald Stein Pathodiagnostik

678 views • 34 slides
Interstitial lung disease: identification and patient referral Professor Joanna Porter, Consultant

Interstitial lung disease: identification and patient referral Professor Joanna Porter, Consultant

RCGP accredited until 1 st April 2020 RCN accredited until 2 nd July 2020 Accreditation applies only to the educational content and not to any product RCN cannot confirm competence of any practitioner Interstitial lung disease: identification

563 views • 13 slides
Case Newspaper: USA TODAY 43 year old man - surgery, radiation for benign pituitary tumor

Case Newspaper: USA TODAY 43 year old man - surgery, radiation for benign pituitary tumor

Disclosures Adult Growth Hormone Deficiency (GHD) PI of research grants to Massachusetts General Hospital from: Novo Nordisk Opko Versartis Beverly MK Biller MD, FACP Occasional consultant to: Novo Nordisk Professor of Medicine Pfizer

258 views • 12 slides
HISTORY ART Pre- Historic Art Egyptian Art Greek Art Roman Art Byzantine Art Medieval Art

HISTORY ART Pre- Historic Art Egyptian Art Greek Art Roman Art Byzantine Art Medieval Art

HISTORY ART Pre- Historic Art Egyptian Art Greek Art Roman Art Byzantine Art Medieval Art Gothic Art Renaissance Art Elaborate Construction Flying Buttress Pointed Vault Stain Glass Windows Northern France Pre- Historic Egyptian

234 views • 4 slides
Campaign gn S Stor orage stor orage f for or tiers space ce f for or everything Peter

Campaign gn S Stor orage stor orage f for or tiers space ce f for or everything Peter

Campaign gn S Stor orage stor orage f for or tiers space ce f for or everything Peter Braam Co-founder &amp; CEO Campaign Storage, LLC 2017-05 campaignstorage.com Contents Brief overview of the system Creating and updating

504 views • 34 slides
Galaxy as an educational tool and community resources for undergraduate training PAG 2020

Galaxy as an educational tool and community resources for undergraduate training PAG 2020

Galaxy as an educational tool and community resources for undergraduate training PAG 2020 Slides: http://bit.do/teach-gxy-pag-2020 Galaxy Team Mo Heydarian https://galaxyproject.org Johns Hopkins University https://help.galaxyproject.org

672 views • 44 slides
Dynamic programming using histomorphisms Jevgeni Kabanov Viinistu, 2005 Catamorphism (fold)

Dynamic programming using histomorphisms Jevgeni Kabanov Viinistu, 2005 Catamorphism (fold)

Dynamic programming using histomorphisms Jevgeni Kabanov Viinistu, 2005 Catamorphism (fold) Structural recursion combinator Generic foldr (Haskell) Eats (folds) trees from bottom-up, producing combined result Similar to Visitor

905 views • 45 slides
PLR Code SIRun4.cxx Pretty self explanatory Sets up a timer to time the process kill

PLR Code SIRun4.cxx Pretty self explanatory Sets up a timer to time the process kill

PLR Code SIRun4.cxx Pretty self explanatory Sets up a timer to time the process kill warning messages Make sure each run uses a different random seed Creates the workspace using the MakeWorkspace method from

1.59k views • 122 slides
Chai: Collaborative Heterogeneous Applications for Integrated-architectures Juan Gmez-Luna 1 ,

Chai: Collaborative Heterogeneous Applications for Integrated-architectures Juan Gmez-Luna 1 ,

Chai: Collaborative Heterogeneous Applications for Integrated-architectures Juan Gmez-Luna 1 , Izzat El Hajj 2 , Li-Wen Chang 2 , Vctor Garca-Flores 3,4 , Simon Garcia de Gonzalo 2 , Thomas B. Jablin 2,5 , Antonio J. Pea 4 , and Wen-mei Hwu

482 views • 31 slides
Introduction to Cataloging Kentucky Department for Libraries and Archives April 2019 Why do we

Introduction to Cataloging Kentucky Department for Libraries and Archives April 2019 Why do we

Introduction to Cataloging Kentucky Department for Libraries and Archives April 2019 Why do we catalog? What do you have? Where do I find it? What is a catalog? History of Cataloging Rules Worldwide perspective Shared cataloging

1.1k views • 63 slides
Recent advances in the development of ice cloud bulk scattering and absorption models for use with

Recent advances in the development of ice cloud bulk scattering and absorption models for use with

Recent advances in the development of ice cloud bulk scattering and absorption models for use with hyperspectral IR data Bryan A. Baum Space Science and Engineering Center University of Wisconsin-Madison Ping Yang and colleagues Texas A&amp;M

500 views • 21 slides
Histo Histo Histo LocalityDescriptor ldesc(); LocalityDescriptor ldesc(X, Y, Z);

Histo Histo Histo LocalityDescriptor ldesc(); LocalityDescriptor ldesc(X, Y, Z);

Histo Histo Histo LocalityDescriptor ldesc(); LocalityDescriptor ldesc(X, Y, Z); LocalityDescriptor ldesc(X, Y, Z); LocalityDescriptor ldesc(A, len, INTER-THREAD, tile, loc); LocalityDescriptor ldesc(A); LocalityDescriptor ldesc(A,

855 views • 49 slides
HW/SW Codesign FSMD I ECE 522 FSMDs VHDL Essentials covers FSMD design principles Here, we

HW/SW Codesign FSMD I ECE 522 FSMDs VHDL Essentials covers FSMD design principles Here, we

HW/SW Codesign FSMD I ECE 522 FSMDs VHDL Essentials covers FSMD design principles Here, we consider an interesting example that builds on the secure memory access controller (SMAC) discussed previously The SMAC functionality allows C programs

321 views • 18 slides
High Performance Liquid Chromatography David Reckhow CEE 772 # 18 1 HPLC System David Reckhow

High Performance Liquid Chromatography David Reckhow CEE 772 # 18 1 HPLC System David Reckhow

Updated: 3 November 2014 Print version High Performance Liquid Chromatography David Reckhow CEE 772 # 18 1 HPLC System David Reckhow CEE 772 # 18 2 Instrument Basics INJECTION PUMP POINT DETECTOR COLUMN RECORDER COLLECTOR MOBILE

529 views • 42 slides

More recommend