Chapter 8: Dictionaries II

• The dictionary ADT models a searchable collection of key-element items
• The main operations of a dictionary are searching, inserting, and deleting items
• Multiple items with the same key are allowed
• Applications:
• address book
• credit card authorization
• mapping host names (e.g., www.nbu.bg) to internet addresses (e.g., 193.19.172.24)
• As an ADT, a dictionary D supports the following functions:

8.2 Hash Tables

• One of the most efficient ways to implement a dictionary is to use a hash table.
• Although hash tables have high worst-case running times for dictionary ADT operations, we will see that their expected-case running time are excellent.
• Letting n denote the number of items, the worst-case running times are O(n), but the expected-case times are only O(1).

• A bucked array for a hash table is an array A of size N, where each cell of A is thought of as a "bucket" (that is, a container of key-element pairs) and the integer N denotes the capacity of the array.
• If the keys are integers well distributed in the range [0, N - 1], this bucket array is all that is needed − an element e with a key k is simply inserted into the bucket A[k].
• If keys are not unique, then two different elements may be mapped to the same bucket in A. In this case, we say that a collision has occurs.

• Achivеment: O(1) for all functions
• Drawback 1: It uses space Theta(N), wasteful when N is large relative to n
• Drawback 2: Keys are integers in [0, N - 1], which is often not the case

• A hash function h maps keys of a given type to integers in a fixed interval [0, N − 1]
• Example: h(x) = x mod N is a hash function for integer keys
• The integer h(x) is called the hash value of key x
• A hash table for a given key type consists of
• Hash function h
• Array of size N
• When implementing a dictionary with a hash table, the goal is to store item (k, e) at index i =  h(k)
• Example:

We design a hash table for a dictionary storing items (SSN, Name), where SSN (social security number) is a nine-digit positive integer Our hash table uses an array of size N = 10 000 and the hash function h(x) = last four digits of x To avoid any collision, we have to use N = 10 000 000 000 and the hash function h(x) = x (Drawback 1)

• A hash function is usually specified as the composition of two functions:
• Hash code map: h₁: keys → integers
• Compression map: h₂: integers → [0, N − 1]
• The hash code map is applied first, and the compression map is applied next on the result, i.e. h(x) = h₂(h₁(x))
• The goal of the hash function is to "disperse" the keys in an apparently random way
• The hash function is "good" if it maps the keys in out dictionary to minimize collisions as much as possible.
• Also it should be fast and easy to compute.

• The integer assigned to a key k is called the hash code or hash value for k.

• Memory address:
• We reinterpret the memory address of the key object as an integer
• Good in general, except for numeric and string keys
• Integer cast:
• We reinterpret the bits of the key as an integer
• Suitable for keys of length less than or equal to the number of bits of the integer type (e.g. char, short, int and float on many machines)
• Component sum:
• We partition the bits of the key into components of fixed length (e.g. 16 or 32 bits) and we sum the components, ignoring overflows
• Suitable for numeric keys of fixed length greater than or equal to the number of bits of the integer type (e.g. long and double on many machines)

int hashCode(int x)
{ return x; }

int hashCode(long x)
{  typedef unsigned long ulong;
   return hashCode(static_cast<int>(static_cast<ulong>(x) >> 32) 
          + static_cast<int>(x));
}

• Polynomial accumulation:
• We partition the bits of the key into a sequence of components of fixed length (e.g., 8, 16 or 32 bits) a₀ a₁… a_n−1
• We evaluate the polynomial
  p(z) = a₀ + a₁z + a₂ z^₂ + … + a_n−1z^_n−1
  at a fixed value z, ignoring overflows
• Especially suitable for strings (e.g., the choice z = 33 gives at most 6 collisions on a set of 50 000 English words!)
• Polynomial p(z) can be evaluated in O(n) time using Horner’s rule:
• The following polynomials are successively computed, each from the previous one in O(1) time
  p₀(z) = a_n−1,  p_i(z) = a_n−i−1 + zp_i−1(z) (i = 1, 2, …, n − 1)
• We have p(z) = p_n−1(z)

int hashCode(const char* p, int len) // hash a character array
{ unsigned int h = 0;
  for (int i = 0; i < len; i++)
  { h = (h << 5)|(h >> 27);          // 5-bit cyclic shift
    h += (unsigned int)p[i];         // add in next character
  }
  return hashCode(int(h));
}

int hashCode(const double& x)       // hash a double
{ int len = sizeof(x);
  const char* p = reinterpret_cast<const char *>(&x);
  return hashCode(p, len);
}

8.2.4 Compression Maps

• The hash code for a key k will typically not be suitable for immediate use with a bucket array, because the range of possible hash codes for our keys will typically exceed the range of legal indices of our bucket array A.

• h₂(y) = | y | mod N
• The size N of the hash table is usually chosen to be a prime number
  
• The reason has to do with number theory and is beyond the scope of this course

• h₂(y) = |ay + b| mod N
• a and b are nonnegative integers such that a mod N ≠ 0
• Otherwise, every integer would map to the same value b

• Collisions occur when different elements are mapped to the same cell

• Chaining: let each cell in the table point to a linked list of elements that map there
• Chaining is simple, but requires additional memory outside the table

Open Addressing Approach
Open addressing: the colliding item is placed in a different cell of the table

Linear Probing

• Linear probing handles collisions by placing the colliding item in the next (circularly) available table cell
• Each table cell inspected is referred to as a “probe”
• Colliding items lump together, causing future collisions to cause a longer sequence of probes
• Example:
  

h(x) = x mod 13 Insert keys 18, 41, 22, 44, 59, 32, 31, 73, in this order

• To handle insertions and deletions, we introduce a special object, called AVAILABLE, which replaces deleted elements
• removeElement(k)
• We search for an item with key k
• If such an item (k, e) is found, we replace it with the special item AVAILABLE and we return the position of this item
• Else, we return a null position
• insertItem(k, e)
• We throw an exception if the table is full
• We start at cell h(k)
• We probe consecutive cells until one of the following occurs:
• A cell i is found that is either empty or stores AVAILABLE, or
• N cells have been unsuccessfully probed
• We store item (k, e) in cell i

• Double hashing uses a secondary hash function d(k) and handles collisions by placing an item in the first available cell of the series (i+ jd(k)) mod N for j = 0, 1, … , N −1
• The secondary hash function d(k) cannot have zero values
• The table size N must be a prime to allow probing of all the cells
• Common choice of compression map for the secondary hash function: d₂(k) = q − k mod q where
• q < N
• q is a prime number
  
• The possible values for d₂(k) are 1, 2, … , q
• Example:

Consider a hash table storing integer keys that handles collision with double hashing N = 13 h(k) = k mod 13 d(k) = 7 − k mod 7 Insert keys 18, 41, 22, 44, 59, 32, 31, 73, in this order

8.2.7 A C++ Hash Table Implementation