Hashing

General Idea
• Facilitates search ideally in O(1) time
• The ideal hash table structure is merely an array of some fixed
size, containing the items.
• A stored item needs to have a data member, called key, that
will be used in computing the index value for the item.
• Key could be an integer, a string, etc
▪ e.g. a name or Id that is a part of a large employee structure
• The size of the array is TableSize.
• The items that are stored in the hash table are indexed by
values from 0 to TableSize – 1.
• Each key is mapped into some number in the range 0 to
TableSize – 1.
• The mapping is called a hash function.
 Example Hash

0 Table
1
Item
2
s 25000
john
3 john 25000
Hash
phil 31250 ke Functio 4 phil 31250
y n
dave 27500 5
mary 28200 6 dave 27500
7 mary 28200
ke 8
y 9
 Hash Function
• Function H from set of K keys to set of L memory
locations
▪ H:K →L
• The hash function:
▪ must be simple to compute.
▪ must distribute the keys evenly among the cells.
• If we know which keys will occur in advance we can
write perfect hash functions, but we don’t
• Problems:
▪ Keys may not be numeric.
▪ Number of possible keys is much larger than the space
available in table.
• Different keys may map into same location
▪ Hash function is not one-to-one => collision.
 Some popular hash functions

• Division Method
• Midsquare Mthod
• Folding Method
 Division Method

• h(k) = k mod M
• Generally, it is best to choose M to be a prime
number because making M a prime increases
the likelihood that the keys are mapped with
a uniformity in the output range of values.
 Midsquare Method
• Step 1: Square the value of the key. That is,
find k 2
• Step 2: Extract the middle r bits of the result
obtained in Step 1 where r is the size of the
Example: Calculate the hash value for keys 1234 and 5642 using the mid
address
square of hash
method. The location
table has 100 memory locations.

Note the hash table has 100 memory locations whose indices vary from
0-99. this means, only two digits are needed to map the key to a
location in the hash table, so r = 2.

When k = 1234, k2 = 1522756, h (k) = 27

When k = 5642, k 2 = 31832164, h (k) = 21

Observe that 3rd and 4th digits starting from the right are chosen.
 Folding Method
• The folding method works in two steps.
• Step 1: Divide the key value into a number of parts. That is
divide k into parts, k1, k2, …, kn, where each part has the same
number of digits except the last part which may have lesser
digits than the other parts.
• Step 2: Add the individual parts. That is obtain the sum of k1 +
k2 + .. + kn. Hash value is produced by ignoring the last carry,
if any.
• Note that the number of digits in each part of the key will vary
depending upon the size of the hash table. For example, if the
hash table has a size of 1000. Then it means there are 1000
locations in the hash table. To address these 1000 locations, we
will need at least three digits, therefore, each part of the key
must have three digits except the last part which may have
lesser digits.
 Collision Resolution

• Collision occurs when the hash

function maps two different keys to
same location
• Methods for handling collision:
• Open addressing
▪ Linear Probing
▪ Quadratic Probing
▪ Double Hashing
• Chaining
Collision Resolution with Open Addressing
• In an open addressing hashing system, all the
data go inside the table.
– Thus, a bigger table is needed.
• Generally the load factor should be below 0.5.
– If a collision occurs, alternative cells are tried until an
empty cell is found.
• More formally:
– Cells h 0(x), h 1(x), h 2(x), …are tried in succession where
h i (x) = (hash(x) + f(i)) mod TableSize, with f(0) = 0.
– The function f is the collision resolution strategy.
• There are three common collision resolution
strategies:
– Linear Probing
– Quadratic probing
– Double hashing
 Linear Probing

• In linear probing, collisions are

resolved by sequentially scanning an
array (with wraparound) until an
empty cell is found.
▪ i.e. f is a linear function of i, typically f(i)= i.
• Example:
▪ Insert items with keys: 89, 18, 49, 58, 9
into an empty hash table.
▪ Table size is 10.
▪ Hash function is hash(x) = x mod 10.
o f(i) = i;
Linear probing
hash table after
each insertion
 Find and Delete

• The find algorithm follows the same

probe sequence as the insert algorithm.
▪ A find for 58 would involve 4 probes.
▪ A find for 19 would involve 5 probes.
• We must use lazy deletion (i.e. marking
items as deleted)
▪ Standard deletion (i.e. physically
removing the item) cannot be performed.
▪ e.g. remove 89 from hash table
 Clustering Problem

• As long as table is big enough, a free

cell can always be found, but the time
to do so can get quite large.
• Worse, even if the table is relatively
empty, blocks of occupied cells start
forming.
• This effect is known as primary
clustering.
• Any key that hashes into the cluster
will require several attempts to resolve
 Quadratic Probing

• Quadratic Probing eliminates primary

clustering problem of linear probing.
• Collision function is quadratic.
▪ The popular choice is f(i) = i 2.
• If the hash function evaluates to h and a
search in cell h is inconclusive, we try cells h
+ 1 2, h+22, … h + i 2.
▪ i.e. It examines cells 1,4,9 and so on away from
the original probe.
• Remember that subsequent probe points
are a quadratic number of positions from
the original probe point.
A quadratic
probing hash table
after each insertion
(note that the table
size was poorly
chosen because it is
not a prime
number).
 Double Hashing

• A second hash function is used to drive the

collision resolution.
▪ f(i) = i * hash2(x)
• We apply a second hash function to x and
probe at a distance hash2(x), 2*hash2(x), …
and so on.
• The function hash2(x) must never evaluate to
zero.
▪ e.g. Let hash2(x) = x mod 9 and try to insert 99 in
the previous example.
 Chaining
• The idea is to keep a list of all elements
that hash to the same value.
– The array elements are pointers to the first
nodes of the lists.
– A new item is inserted to the front of the list.
• Advantages:
– Better space utilization for large items.
– Simple collision handling: searching linked
list.
– Overflow: we can store more items than the
hash table size.
– Deletion is quick and easy: deletion from the
linked list.
 Example
Keys: 0, 1, 4, 9, 16, 25, 36, 49, 64, 81
hash(key) = key % 10.
0 0

1 81 1
2

4 64 4
5 25
6 36 16
7

9 49 9
 Operations
• Initialization: all entries are set to NULL
• Find:
– locate the cell using hash function.
– sequential search on the linked list in that cell.
• Insertion:
– Locate the cell using hash function.
– (If the item does not exist) insert it as the first
item in the list.
• Deletion:
– Locate the cell using hash function.
– Delete the item from the linked list.