Hash Table

• Keys are directly associated with the addresses of the corresponding objects.
• The simplest case
  • a bucket array of size N, where N defines the capacity of the array, as the hash table
  • the keys of all objects are integers well distributed in the range of 0 to N-1
  • keys are used to directly and uniquely find where the objects are
  • performance: insert, remove, and lookup all take O(1) time
• Issues:
  • How to choose the appropriate capacity N? N should be much larger than the number of objects stored in the hash table. But if N is too large, a lot of the storage space is wasted.
  • Sometimes, keys are not integers or integers but not in the range of 0 to N-1.
  • Conflict could happend if keys are not unique or if h(k) = h(k') where k =/= k'.
• A good hash function maps any key to an integer in the range of 0 to N-1, and minimizes the possibility of h(k) = h(k') when k =/= k', and is fast and easy to compute.
• Hash Function generally takes two steps:
  • generate integer hash code for keys that are not integers;
  • compress the hash code into the range of 0 to N-1.
• Polynomial Hash Code
  • Gnerate hash code for any integer representation sequence (x₀, ..., x_p). String can be viewed as such a sequence.
  • Pick a non-zero constant a such that a =/= 1,
    h(k) = x₀a^p + x₁a^p-1 + ... + x_p-1a + x_p
    which can be re-written as:
    h(k) = x_p + a(x_p-1 + a(x_p-2 + ... + a(x₂ + a(x₁ + ax₀))...))
  • Advantage of polynomial hash code:
    easy to compute
    experimental studies show that if a is 33, 37, 39 or 41, then the hash function works very well with English words.
• MAD -- Multiply, Add and Divide
  • Map hash code to an integer in the range of 0 to N-1, where N is the capacity of the hash table.
  • h(k) = abs(ak + b) mod N
  • It works best if N is a prime number.
  • a and b are randomly chosen, non-negative integers and a mod N =/= 0.
• After the hashing, we hope the n keys will be distributed in the range of 0 to N-1, such that the probability of any two different keys will collide is at most 1/N, i.e., the probability is the same as we randomly put keys into the bucket array.
• Collision
  • There is always 1/N possibility that collision will happen no matter how good the hash function is. And keys may not even be unique.
  • Separate Chaining to handle collision
    • store a pointer pointing to an external unsorted dictionary in the bucket cell.

      Data & lookup (Key k)
      {
          int index = h(k);
          head = bucket[index];
          while (head != 0 && head->key != k)
              head = head -> next;
          if (head == 0)
              throw exception of data not found;
          else
              return head->object;
      }
      

    • load factor (n/N) is about the average length of the external dictionary. And the load factor determines the performance the hash table operations.
    • Re-hashing to keep the load factor a constant. Note that N will be changed so the hash function will also change.
  • Open addressing to handle collision
    • Handle collisions within the fixed storage space. When collision happened, go to the next spot by jumping a pre-designed offset.
    • h is the hash function and g is the pre-designed offset calculator, each cell in the bucket has one of the following three states: Occupied, Free, Removed.

      void insert(Key k, Data & object)
      {
          int index = h(k);
          int i = index;
          for(int j = 1; bucket[i] is Occupied; j++)
              i = (i + g(j, k)) mod N;
          insert object to bucket[i];
          change bucket[i].status to Occupied;
      }
      
      Data & lookup(Key k)
      {
          int index = h(k);
          int i = index;
          for(int j = 1; bucket[i] is not Free; j++) {
              if (bucket[i] is Occupied && bucket[i].key == k)
                  return bucket[i].object;
              i = (i + g(j, k)) mod N;
          }
          throw exception of not found;
      }
      
      Data & remove(Key k)
      {
          int index = h(k);
          int i = index;
          for(int j = 1; bucket[i] is not Free; j++) {
              if (bucket[i] is Occupied && bucket[i].key == k) {
                  change bucket[i].state to Removed;
                  return bucket[i].object;
              }
              i = (i + g(j, k)) mod N;
          }
          throw exception of not found;
      }
      

    • To calculate the offset:
      • linear probing: g(j, k) = 1; May cause clustering
      • quadratic probing: g(j, k) = j * j; May not be able to find a spot even if the array is not full
      • double hashing: g(j, k) = h'(k); usually h'(k) = q - (k mod q); where q is a prime number that is less than N.
• Universal Hashing
  • A randomly picked hash function may perform poorly. Universal hashing wants to provide a set of good candidates.
  • Problem definition:
    After the hash code been generated, the problem can be viewed as mapping integers from range of 0 to M-1 to integers in the range of 0 to N-1.
    We consider the set of candidate hash functions that can do the mapping as a family H of hash functions.
    For example,
    H1 = {h | h(k) = k^a mod N, a > 1}, or
    H2 = {h | h(k) = (ak + b) mod N, a > 0 b >= 0}
  • A family H is called a universal family if it satisfy the following condition: we randomly pick a function h from this family, and for any pair of integers k1 and k2 in the range of 0 to M-1, the probability that Pr(h(k1) == h(k2)) <= 1/N.
  • If you pick hash functions from the universal family, then the good performance is guaranteed.
  • A practical way to find a universal family:
    Given M and N, find a prime number P such that M < P < 2M. (By the way, according to Bertrand's Postulate, there must exist such a P.)
    H = {h_{a, b} | 0 < a < P and 0 <= b < P, h_{a, b}(k) = ((ak + b) Mod P) Mod N }