Hashing Functions

The Division Method ( for integers )

•  h ( k ) = k mod M, where k is the integer key and M is the size of the hash table

 
• M must be chosen carefully with the properties of the data in mind
• Example of poor choice -- M = 10 and all keys are multiples of 10


   70 mod 10 = 0
    80 mod 10 = 0
   120 mod 10 = 0

    all keys hash to the same value
 

• Another poor choice -- M = 2^b (b > 1, M is a power of 2)


    then h ( k ) = k mod 2^b just extracts the bottom b bits from k
 
 

• The best choice -- M is prime number


    Rule of thumb -- select table size such that table is never more than 80% full 

             Let M_min = expected-number-of-entries / 0.8

            Choose M = smallest prime > M_min

The Multiplication Method ( for integers )

• h ( k ) = |_ M * ( k * A - |_ k * A _| ) _|


    where A is some real positive constant.
    note that ( k * A - |_ k * A _| ) is between 0.0 and 1.0
 

• Good choice for A -- the inverse of the golden ratio


   golden ratio  Ø =   ( 1 + sqrt (5) ) / 2 = 1.618033989....

    so Ø^-1 = 1 / 1.618033989...  =  0.618033989
 

• Because of the relationship between the golden ratio and
  Fibonacci numbers, this is also called "Fibonacci hashing"

 

 

    h ( k ) = |_ M * ( k * Ø^-1 - |_ k * Ø^-1 _| ) _|

    Some values for k and h ( k )
 
 

k	h ( k )
0	0
1	0.618 * M
2	0.236 * M
3	0.854 * M
4	0.472 * M
5	0.090 * M
6	0.708 * M
7	0.326 * M
8	0.562 * M
9	0.562 * M

What if the keys aren't integers?

• Need to map the key to an integer, then use one of the techniques above
  
  
• h ( k ) has two parts
• function f maps the universe of keys onto the integers  f : U -> ints
• function g hashes the resulting integer  g : I -> { 0, 1, 2, .... M - 1}
  using division or multiplication method above
  
  
• so  h ( k ) = g ( f ( k ) )
• When k is already a positive integer, then f ( k ) = k
  
  

How do we convert strings to positive integers?

• An obvious ( but poor ) choice -- add the ASCII values
  
  
• A better choice -- compute a polynomial using the characters as the constants