Chapter 5: Hashing

Hashing

Hash Table:

an array of fixed size $Table\_Size$

Hash Function:

maps keys into numbers in the range $0-Table\_Size-1$

Goal:

distribute keys evenly among array
elements

Collision:

two keys hash to same value

Open Hashing (Separate Chaining)

• use a hash function to determine hash value
• keep a list of all elements that hash to the same value

Load Factor of Hash Table ($\lambda$)

# of elements in hash table / table size

Successful search:

$(1+\lambda/2)$ links traversed on average

Unsuccessful search:

$\lambda$ links traversed on
average

Therefore:

• make table size large (to reduce $\lambda$)
• table size = prime number: helps in good distribution

Open Addressing

• try alternative cells on collision
• stop when empty cell found

$$h_i(x) = (Hash(x) + f(i)) mod~Table\_Size$$

where f(0) = 0

• does not require pointers
• a bigger table needed
• lower load factor ($\lambda$)
• lazy deletion

Collision Resolution Strategies

Linear Probing: f(i) = i

• free cell can be found if table is not full
• primary cluster formation: time consuming
• can be very expensive if table is quite full

Expected number of probes:

• insertion, unsuccessful search: $\frac{1}{2}(1 + \frac{1}{(1- \lambda)^2})$
• successful searches: $\frac{1}{2}(1 + \frac{1}{1 - \lambda})$

Collision Resolution (contd.)

Quadratic Probing: f(i) = i²

• eliminates primary clustering problem
• no guarantee of finding an empty cell
  (especially if table size is not prime)
• at most half the table can be used as alternative location for conflict resolution

Double Hashing: $f(i) = i \times hash_2(x)$

• very efficient for good choices of hash₂ function

Rehashing

• Open addressing may have poor
  performance when table gets too full.
• Solution:
  • built another table about twice as big,
  • use a new hash function,
  • compute new hash value for each
    nondeleted element,
  • insert elements in new table.

Extendible Hashing

• Maintain a directory.
• Insert and finds performed with few disk accesses.
• Possible to restructure the directory
  without actually accessing the data.