1. COSC 1030 Lecture 10 Hash Table

2. Topics Table Hash Concept Hash Function Resolve collision Complexity Analysis

3. Table Table – A collection of entries – Entry : – Insert, search and delete – Update, and retrieve Array representation – Indexed – Maps key to index

4. Hash Table – A table – Key range >> table size – Many-to-one mapping (hashing) – Indexed – hash code as index Tabbed Address Book – Map names to A:Z – Multiple names start with same letter Same tab, sequential slots

5. Hash Table ADT Interface Hashtable { void insert(Item anItem); Item search(Key aKey); boolean remove(Key aKey); boolean isFull(); boolean isEmpty(); }

6. Hash Function Maps key to index evenly For any n in N, hash(n) = n mod M where M is the size of hash table. hash(k*M + n) = n, where n < M, k: integer Map to integer first if key is not an integer – A:Z  0:25 String s  h(s[0]) + h(s[1])*26 +…+ h(s[n-1])*26^(n-1) String s  h(s[0])*26^(n-1) + …+h(s[n-1])

7. Hash Function String s  h(s[0])*26^(n-1) + …+h(s[n-1]) int toInt(String s) { assert(s != null); int c = 0; for (int I = 0; I < s.length(); I ++) { c = c*26 + toInt(s.charAt(I)); } return c; } int hash(String s) { return hash(toInt(s)); }

8. Example Table[7] – HASHTABLE_SIZE = 7 Insert ‘B 2 ’, ‘H 7 ’, ‘M 12 ’, ‘D 4 ’, ‘Z 26 ’ into the table 2, 0, 5, 4, 5 Collision – The slot indexed by hash code is already occupied A simple solution – Sequentially decreases index until find an empty slot or table is full

9. Collision Possibility How often collision may occur? Insert 100 random number into a table of 200 slots 1 –  ((200 – I)/200), I=0:99 = 1 – 6.66E-14 > 0.99999999999993 Load factor – 100/200 = 0.5 = 50%  0.99999999999993 – 20/ 200 = 0.1 = 10%  0.63 – 10/200 = 0.05 = 5%  0.2 Default load factor is 75% in java Hashtable

10. Primary Cluster The biggest solid block in hash table Join clusters The bigger the primary cluster is, the easier to grow Distributed evenly to avoid primary cluster

11. Probe Method What we can do when collision occurred? – A consistent way of searching for an empty slot – Probe Linear probe – decrease index by 1, wrap up when 0 Double hash – use quotient to calculate decrement –Max(1, (Key / M) % M) Separate chaining – linked list to store collision items Hash tree – link to another hash table (A4)

12. Probe sequence coverage Ensure probe sequence cover all table – Utilizes the whole table – Even distribution – M and probe decrement are relative prime No common factor except 1 – Makes M a prime number M and any decrement (< M) are relative prime

13. Probe Method void insert(Item item) { if(!isFull()) { int index = probe(item.key); assert(index >=0 && index < M); table[index] = item; count ++; }

14. Linear Probe Method int probe(int key) { int hashcode = key % HASHTABLE_SIZE; if(table[hashcode] == null) { return hashcode; } else { int index = hashcode; do { index--; if(index < 0) index += HASHTABLE_SIZE; } while (index != hashcode && table[index] != null); if(index == hashcode) return –1; else return index; }

15. Double Hash Probe Method int probe(int key) { int hashcode = key % HASHTABLE_SIZE; if(table[hashcode] == null) { return hashcode; } else { int index = hashcode; int dec = (key / HASHTABLE_SIZE) % HASHTABLE_SIZE; dec = Math.max(1, dec); do { index -= dec; if(index < 0) index += HASHTABLE_SIZE; } while (index != hashcode && table[index] != null); if(index == hashcode) return –1; else return index; }

16. Search Method Item search(int key) { int hashcode = key % HASHTABLE_SIZE; int dec = max(1, (key / HASHTABLE_SIZE) % HASHTABLE_SIZE); while(table[hashcode] != null) { if(table[hashcode].key == key) break; hashcode -= dec; } return table[hashcode]; }

17. Delete Method Difficulty with delete when open addressing – Destroy hash probe chain Solution – Set a deleted flag – Search takes it as occupied – Insert takes it as deleted – Forms primary cluster Separate chaining – Move one up from chained structure

18. Efficiency Successful search – Best case – first hit, one comparison – Average Half of average length of probe sequence Load factor dependent O(1) if load factor < 0.5 – Worst case – longest probe sequence Load factor dependent Unsuccessful search – Average - average length of probe sequence – Worst case - longest probe sequence

19. Advanced Topics Choosing Hash Functions – Generate hash code randomly and uniformly – Use all bits of the key – Assume K=b0b1b2b3 – Division h(k) = k % M; p(k) = max (1, (k / M) % M) – Folding h(k) = b1^b3 % M; p(k) = b0^b2 % M; // XOR – Middle squaring h(k) = (b1b2) ^ 2 – Truncating h(k) = b3;

20. Advanced Topics Hash Tree – Separate chained collision resolution – Recursively hashing the key Hash Table

21. Hash Tree void insert(int key, Item item) { Int h = h(key); Int k = g(key); // one-to-one mapping Key  Key If(table[h] == null) { table[h] = item; } else { if(table[h].link == null) table[h].link = new HashTree(); table[h].link.insert(k, item); }