1 / 21

COSC 1030 Lecture 10

COSC 1030 Lecture 10. Hash Table. Topics. Table Hash Concept Hash Function Resolve collision Complexity Analysis. Table. Table A collection of entries Entry :<key, info> Insert, search and delete Update, and retrieve Array representation Indexed Maps key to index. Hash Table.

kalea
Download Presentation

COSC 1030 Lecture 10

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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 :<key, info> • Insert, search and delete • Update, and retrieve • Array representation • Indexed • Maps key to index

  4. Hash Table • 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 Mwhere 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 ‘B2’, ‘H7’, ‘M12’, ‘D4’, ‘Z26’ 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 Hash Table Hash Table Hash Table Hash Table 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); } }

More Related