Class 52: Implementing Dictionaries with Hash Tables

Held: Friday, 2 May 2003

Summary: Today we consider one of the most important implementations of dictionaries, Hash tables.

Related Pages:

• EBoard.
• Documentation for java.util.Hashtable.

Notes:

• Are there questions on exam 4?
• Please send me a summary of the extra credit you believe you deserve for this class.

Overview:

• Dictionaries vs. Arrays.
• The Idea of Hashing.
• Hash Functions.
• Hashing in Java.
• Handling Hashing Conflicts.
• Exceptions.

Hash Tables

• As you may have noticed, although dictionaries are a lot like arrays (except that you index dictionaries by object and arrays by number).
• However, in terms of implementation, that claim hasn't held.
  • The unordered list implementation has O(n) add and O(n) get.
  • The ordered array implementation has O(n) add and O(log₂n) get.
• The corresponding array operations are O(1).
• Is there a dictionary implementation with O(1) get and add?
• Surprisingly, if you're willing to sacrifice some space and increase your constant, it is possible to build a dictionary that is likely to have O(1) get and add.
• How? Well, we know that arrays provide O(1) get and add, so use arrays.
• How do we use an array? We "number" the keys in such a way that
  • all numbers are between 0 and array.length-1
  • no two keys have the same number (or at least few have the same number).
• If there are no collisions (keys with the same number), the system is simple
  • To add a value, determine the number corresponding to the key and add it in that place of the array. This is O(1+cost of computing that number).
  • To get a value, determine the number corresponding to the key and look in the appropriate cell. This is O(1+cost of finding that number).
• Implementations of dictionaries using this strategy are called hash tables.
• The function used to convert an object to a number is the hash function.
• To better understand hash tables, we need to consider
  • The hash functions we might develop.
  • What to do about collisions.

Hash Functions

• The goal in developing a hash function is to come up with a function that is unlikely to map two objects to the same position.
  • Now, this isn't possible (particularly if we have more objects than positions).
  • We'll discuss what to do about two objects mapping to the same position later.
• Hence, we sometimes accept a situation in which the hash function distributes the objects more or less uniformly.
• It is worth some experimentation to come up with such a function.
• In addition, we should consider the cost of computing the hash function. We'd like something that is relatively low cost (not just constant time, but not too many steps within that constant).
• We'd also like a function that does (or can) give us a relatively large range of numbers, so that we can get fewer collisions by increasing the size of the hash table.
  • We might want to make the size of the table a parameter to the hash function.
  • We might strive for a hash function that uses the range of positive integers, and mod it by the size of the table.
• What are some hash functions you might use for strings?
  • Sum the ASCII values in the string
  • N*first letter + M*second letter
  • ...

An Exercise in Hashing

• Let's try an exercise. We'll come up with a hash value for everybody's first name. We'll then put things in the hash table.
• We'll use sum the values of the letters in the name.
• We'll use the following table:

  A: 1   F: 6   K: 11  P: 16  U: 21  Z: 26
  B: 2   G: 7   L: 12  Q: 17  V: 22
  C: 3   H: 8   M: 13  R: 18  W: 23
  D: 4   I: 9   N: 14  S: 19  X: 24
  E: 5   J: 10  O: 15  T: 20  Y: 25
  

• There are N of you in the class. Typically, our hash tables are somewhat bigger than the size of the collection we're working with, so we'll use a hash table of size 2*N.
  • Once you've computed your result, mod it by 2*N.
• For my first name (Samuel), the hash value is 19 (S) + 1 (A) + 13 (M) + 21 (U) + 5 (E) + 12 (L) = 71.
• For my first son's name (William), the hash value is 23 (W) + 9 (I) + 12 (L) + 12 (L) + 9 (I) + 1 (A) + 13 (M) = 79.
• For my second son's name (Jonathan), the hash value is 10 (J) + 15 (O) + 14 (N) + 1 (A) + 20 (T) + 8 (H) + 1 (A) + 14 (N) = 83.
  • For my third son's name (Daniel), the hash value is 4 (D) + 1 (A) + 14 (N) + 9 (I) + 5 (E) + 12 (L) = 45.
  • For my wife's name (Michelle), the hash value is 13 (M) + 9 (I) + 3 (C) + 8 (H) + 5 (E) + 12 (L) + 12 (L) + 5 (E) = 67
• For my last name (Rebelsky), the hash value is 18 (R) + 5 (E) + 2 (B) + 5 (E) + 12 (L) + 19 (S) + 11 (K) + 25 (Y) = 97
• Is this a good hash function?
  • Why?
  • WHy not?

Hashing in Java

• Hash tables are so useful that Java includes them as a standard library class, java.util.Hashtable.
• Let's look over the
• documentation for java.util.Hashtable.
• Why are there three constructors?
• What methods are there other than get and add?
• Where's the hash function?

Handling Conflicting Keys

• Since we typically have many more possible keys than places in the array, we will eventually hit a point in which two keys hash to the same value.
• What should we do when this conflict happens?
• It is not reasonable to disallow the second key, since it's a different key.
• We could put a list of key/value pairs, rather than a singleton, at every position.
• We could step through the array until we find an empty space.

Removing Elements from Hash Tables

• Our analysis of Hash Tables to date has been based on two simple operations: get and add.
• What happens if we want to remove elements? This operation can significantly complicate matters.
• If we've chosen the shift into a blank space technique for resolving collisions, what do we do when it comes time to remove elements?
  • Do we shift everything back? If so, think about how far we may have to look.
  • Do we leave the thing there as a blank? We might then then remove it later when it's convenient to do so.
  • Do we do something totally different?
• Note also that there are different ways of specifying remove. We might remove the element with a particular key. We might instead remove elements based on their value. The second is obviously a much slower operation than the first (unless we've developed a special way to handle that problem - see if you can think of one).