Introduction to Hashing

• A Dictionary is a data structure that supports
  • Searching for an item.
  • Inserting new items.
  • Deleting old items.
  • The hope is that all of these operations can be done in constant time.
  • And the problem is that we frequently have a non-numeric "key".
• Examples:
  • A Dictionary, duh
  • Symbol table for a compiler.
• Hashing is a way to build a dictionary
  • A hash function maps a key to a hash address
  • The hash address is usually a numeric value which is an index into a hash table
  • It is likely that two distinct keys will have the same hash address and this is called a collision
• An ideal hash function
  • Is deterministic.
  • Is fast
  • Correctly maps to the range of indexes of the hash table.
  • spreads the keys out across the range of the table.
  • avoids/reduces collisions.
• In most cases
  • U is the set of potential keys
  • m is the number of spaces in the hash table.
  • |U| > m, so there MUST be collisions.
• Open Hashing or Chaining
  • The hash table is actually an array of linked lists.
  • If list is empty, then nothing is at that location
    • New items can be inserted.
    • Any search mapping to an empty list results in not found.
  • If the list is not empty,
    • It must be searched for the desired key
    • A not found is still possible
    • Or a further insert into the list
• Performance of open hashing
  • Could be as bad as O(n) for all operations
    • Where n is the number of items in the table.
    • And the hash function is "really bad" for the given keys
  • Could be as good as O(1) if the hash function is really good.
  • Assume n items stuck into m slots.
    • A load factor α = n/m
    • If α > 1, then there will be collisions.
    • If α << 1, then there will be wasted space.
  • For key k, T[k] is a list and the length of T[k] is n_k.
  • n = Σ₀^m-1n_k
    • If the keys are uniformly distributed by the hash function,
    • The expected list size is n/m = α
  • We assume that the hash function is O(1)
  • The expected time for an operation will then be O(1+α)
  • Thus we need n ≈ O(m)
• Hash Functions
  • If we know what we are going to be hashing we can build a better hash function.
  • But we frequently don't know.
  • And this is one of the places that someone can intentionally cause problems.
    • Our author suggests (Σ_i=0^s-1ord(S[i]))mod m)
    • This somewhat agnostic computation makes god and dog the same!
  • Building a good hash function is the object of much study.
  • CLRS assumes keys are mapped to natural numbers
    • k = Σ_{i=0s-1 ord(S[i])*128^s-1-i}
    • This may lead to large numbers , they discuss two methods for reducing to a range.
    • So some studies suggest only using the first p letters of long strings.
  • Another book (and wikipedia) suggests casting the value to an int.
    • This may lead to looking at only the first (or last) characters in the string.
  • Division
    • h(k) = k mod m
    • This is quite fast.
    • But the choice of mi is important.
    • a power of 2 will only pick off the lower order bits.
    • A prime number, not close to a power of two is good.
    • Example:

      n ≈ 2000
      We don't mind α ≈ 3
      So m = 2000/3  = 667
      The primes near (larger) are 673    677    683    691    701 
      The authors pick m = 701
      	     

    • This gives us a method for choosing m, but it is somewhat complex.
  • Multiplication
    • Select 0 < A < 1
    • h(k) = ⌊ m (kA mod 1) ⌋,
    • where kA mod 1 = kA - ⌊ kA ⌋
    • Studies suggest that A ≈ .618 is best.
• CLRS discusses Universal Hash Functions.