Module 4: Hashing and Tries

Two problems:

• Valid addresses:
  • If the signature is an integer, how can we use that as a memory address?
  • Some languages (e.g., Java) do not allow direct access to memory.
  • Even in C, the signature may not be a valid address.
  • Solution: use array offsets.

• Uniqueness:
  • What if two keys have the same signature?
    => a collision occurs at the address.
  • Solution: store keys together.

Details:

• Create a table (array) with entries 0,...,m-1.

  

• Each entry represents an address.

• Thus, the addresses are 0,...,m-1.

• Each entry i will contain a linked list used to store keys (and values) that whose signature (hash value) is i.

• Devise a signature function (called hashing function) whose output is one of the values 0,...,m-1:
  • Suppose a signature function f produces values larger than m.
  • Let g(string) = f(string) mod m.
    => g produces values in the range 0,...,m-1.

• Each table entry is sometimes called a bucket.

Example:

• Suppose we want to store the following 51 strings:
  

  "catch", "throws", "break", "byte", "volatile", "throw", "protected", "this", "do", "switch", "boolean", "char", "package", "true", "extends", "new", "instanceof", "for", "public", "return", "while", "case", "abstract", "false", "void", "synchronized", "implements", "finally", "null", "try", "const", "default", "native", "continue", "super", "import", "class", "final", "transient", "short", "double", "long", "private", "goto", "int", "if", "else", "static", "interface", "float"

• We will use the signature (ascii code of the) "first letter of string".

• Initially, the hashtable is empty: each entry is an empty linked list.

  

• Next, when inserting "catch":
  • Compute signature of "catch": signature("catch") = 2.
    (distance from 'a').
  • Compute table index: i = signature mod 26.
    => i = 2.
  • Insert into linked list at entry 2:

    

• After inserting "throws", "break", "byte", "volatile":

  

• ... (remaining steps not shown).

Pseudocode:

• Insertion:

  
  Algorithm: initialize (numBuckets)
  Input: desired number of buckets
  1.   Initialize array of linked lists;
    

  
  Algorithm: insert (key, value)
  Input: key-value pair
       // Compute table entry: 
  1.   entry = key.hashCode() mod numBuckets
  2.   if table[entry] is null
         // No list present, so create one 
  3.     table[entry] = new linked list;
  4.     table[entry].add (key, value)
  5.   else
  6.     // Otherwise, add to existing list 
  7.     table[entry].add (key, value)
  8.   endif
    

• Search:

  
  Algorithm: search (key)
  Input: search-key
       // Compute table entry: 
  1.   entry = key.hashCode() mod numBuckets
  2.   if table[entry] is null
  3.     return null
  4.   else
  5.     return table[entry].search (key)
  6.   endif
  Output: value, if found; null otherwise.
    

• Note: the add and search methods for linked lists are not described.

About signatures:

• Signature functions are usually called hash or hashing functions.

• Hash functions should distribute keys evenly over the buckets:
  • Consider distribution in previous example:

    
    a: 1     ("abstract")
    b: 3     ("boolean", "break", "byte")
    c: 6     ("case", "catch", "char", "class", "const", "continue")
    d: 3     ("default", "do", "double")
    e: 2     ("else", "extends")
    f: 5     ("false", "final", "finally", "float", "for")
    g: 1     ("goto")
    h: 0     
    i: 6     ("if", "implements", "import", "instanceof", "int", "interface")
    j: 0     
    k: 0     
    l: 1     ("long")
    m: 0     
    n: 3     ("native", "new", "null")
    o: 0     
    p: 4     ("package", "private", "protected", "public")
    q: 0     
    r: 1     ("return")
    s: 5     ("short", "static", "super", "switch", "synchronized")
    t: 6     ("this", "throw", "throws", "transient", "true", "try")
    u: 0     
    v: 2     ("void", "volatile")
    w: 1     ("while")
    x: 0     
    y: 0     
    z: 0     
         

  • In contrast, Java's hashing function has the following distribution:

    
    table entry 0:  3
    table entry 1:  0
    table entry 2:  3
    table entry 3:  3
    table entry 4:  0
    table entry 5:  1
    table entry 6:  1
    table entry 7:  1
    table entry 8:  4
    table entry 9:  0
    table entry 10: 0
    table entry 11: 2
    table entry 12: 0
    table entry 13: 2
    table entry 14: 1
    table entry 15: 1
    table entry 16: 0
    table entry 17: 0
    table entry 18: 2
    table entry 19: 2
    table entry 20: 2
    table entry 21: 4
    table entry 22: 1
    table entry 23: 0
    table entry 24: 0
    table entry 25: 0
         

    (A more even, but not perfect distribution).

• A hashing function should include all parts of the key:
  • "first letter" ignores contribution from remainder of string.
  • "add ascii codes of letters" involves all parts.
  • Java's hash function for String's:

    
          int hashValue = 0;
          for (int i=0; i < length; i++) {
            // Note: 31 = 2**5-1. The string characters are assumed to be  
            // stored in charArray[]. 
            hashValue = 31*hashValue + charArray[i];
          }
          return hashValue;
          

In-Class Exercise 4.1: Download this template and the file words (a dictionary). Print out the distribution of words (only the number) over buckets for each of the following keys:

• "first letter"
• "last letter"
• Java's hash function.

Sizing a table:

• If you expect insertion of n keys, how large should the table be?

• With m buckets and uniform distribution, there will be n / m keys per bucket (average).

• Hashing has no guarantees: you can get unlucky and have a large bucket.
  (But probability of large bucket is very small)

• If n is small, consider using a size in the range n to 4n.
  For example: with Java's 51 reserved words and Java's hash function: we need 287 buckets for a perfect distribution (probably excessive).

• If n is large, use 0.5n or smaller.

• If n is very large, use a hash tree:
  • Use a fixed number of buckets (e.g. 100 buckets) at each level.
  • Thus, at the root level (level 0) there is the hashtable itself.
  • Each bucket is a "child" in the tree.
         => There are a 100 children at level 1.
  • Each node at level 1 can have children (the next level)
         => There are 100 x 100 = 10,000 children at level 2
  • A different hash function is used at each level.

Analysis (assuming few keys per bucket):

• Insertion: O(1) (constant).
• Search: O(1) (constant).
• Both search and insertion times are optimal for the search-problem.

Variations:

• Linear probing:
  • Avoid using linked lists: store keys as table entries directly.
  • If a collision occurs, simply scan table looking for next available space.
  • Advantage: avoids space for linked structures.
  • Disadvantage: long scans occasionally required.
• Double-hashing:
  • Like linear-probing, store keys in table.
  • Instead of scanning table for available space, use second hash function to determine where next to try insertion.
• Perfect hashing:
  • Given fixed data, design hash functions to ensure perfect distribution over buckets.
  • Use a series of hash functions instead of a single function.
• External hashing:
  • For hashing when applied to large disk files (that remain on disk).
  • See database course/book for details.

In-Class Exercise 4.2: Suppose you had to use a hash table for a collection of floating-point numbers: x₁, x₂,...,x_n. Design a hashing function to hash to the range 0,...,m.

Geometric Hashing

For a collection of points, (x₁,y₁), (x₂,y₂), ..., (x_n,y_n), consider the following queries:

• Given a query point q, is q in the collection?
• Given a query point q, what is the nearest point to q from the collection?

import java.util.*;

public class Duplicate {

  // Any Map can be used, e.g., TreeMap. 
  static Map originalDataStructure = new HashMap();


  // Insertion. 

  static void insert (Object key, Object value)
  {
    // 1. Attempt a direct insertion. 
    Object oldValue = originalDataStructure.put (key, value);

    // 2. If the value wasn't already there, nothing to be done. 
    if (oldValue == null) {
      // No duplicates. 
      return;
    }

    // 3. Otherwise, check if duplicates already exist. 
    if (oldValue instanceof HashSet) {
      // 3.1 There are, so add the new one. 
      HashSet duplicates = (HashSet) oldValue;
      duplicates.add (value);
    }
    else {
      // 3.2 This is the first duplicate => create a HashSet to store duplicates. 
      HashSet duplicates = new HashSet ();
      // 3.3 Place old value and duplicate in hashset. 
      duplicates.add (oldValue);
      duplicates.add (value);
      // 3.4 Add the hashset itself as the value. 
      originalDataStructure.put (key, duplicates);
    }
  }


  // Enumerate and print all values. 

  static void printAll ()
  {
    Collection values = originalDataStructure.values();
    for (Iterator i=values.iterator();  i.hasNext(); ) {
      Object obj = i.next();
      // If the value is a HashSet, we have duplicates. 
      if (obj instanceof HashSet) {
        // Extract the different values. 
        HashSet duplicates = (HashSet) obj;
        for (Iterator j=duplicates.iterator();  j.hasNext(); ) {
          System.out.println (j.next());
        }
      }
      else {
        // If it's not a HashSet, the extract obj is a value. 
        System.out.println (obj);
      }
    }
  }

  public static void main (String[] argv)
  {
    // Add data with duplicates. 
    insert ("Ali", "Anorexic Ali");
    insert ("Bill", "Bulimic Bill");
    insert ("Bill", "Blasphemous Bill");     // Duplicate. 
    insert ("Chen", "Cadaverous Chen");
    insert ("Dave", "Dyspeptic Dave");
    insert ("Dave", "Duplicitous Dave");     // Duplicate. 
    insert ("Dave", "Diabolical Dave");      // Duplicate. 
    insert ("Ella", "Egregious Ella");
    insert ("Franco", "Flatulent Franco");
    insert ("Gita", "Gluttonous Gita"); 
    insert ("Gita", "Grotesque Gita");       // Duplicate. 

    // Print. 
    printAll();
  }

}