Data Analysis and Applications

Lecture 12 : Hash Tables

Dongjin Ji
Maps and Dictionaries

2
MAPS

A map is a searchable collection of items that are key-value pair

s
The main operations of a map are for searching, inserting, and d
eleting items
Multiple items with the same key are not allowed
Applications:
address book
student-record database

3
DICTIONARIES

Python’s dict class is arguably the most

significant data structure in the language.
It represents an abstraction known as a dictionary in
which unique keys are mapped to associated values.
Here, we use the term “dictionary” when
specifically discussing Python’s dict class, and the
term “map” when discussing the more general
notion of the abstract data type.

4
THE MAP ADT
(USING DICT SYNTAX)

5
MORE MAP OPERATIONS

6
A FEW MORE MAP OPERATIONS

7
EXAMPLE

8
A Simple List-Based Map

We can efficiently implement a map using an

unsorted list
We store the items of the map in a list S (based
on a doubly-linked list), in arbitrary order

header nodes/positions trailer

9 c 6 c 5 c 8 c
Items (key-value pairs)

9
OUR MAPBASE CLASS

10
THE MAPBASE ABSTRACT CLASS

11
AN UNSORTED LIST IMPLEMENTATION

12
Performance of a List-Based Map

Performance:
Inserting an item takes O(1) time since we can insert the new
item at the beginning or at the end of the unsorted list
Searching for or removing an item takes O(n) time, since in
the worst case (the item is not found) we traverse the entire
listto look for an item with the given key
The unsorted list implementation is effective only for
maps of small size or for maps in which insertions are
the most common operations, while searches and
removals are rarely performed (e.g., historical record
of logins to a workstation)
13
Hash Tables

0 ∅
1 025-612-0001
2 981-101-0002
3 ∅
4 451-229-0004

14
RECALL THE NOTION OF A MAP

Intuitively, a map M supports the abstraction of

using keys as indices with a syntax such as M[k].
As a mental warm-up, consider a restricted setting
in which a map with n items uses keys that are
known to be integers in a range from 0 to N − 1,
for some N ≥ n.

15
MORE GENERAL KINDS OF KEYS

But what should we do if our keys are not

integers in the range from 0 to N – 1?
Use a hash function to map general keys to
corresponding indices in a table.
For instance, the last four digits of a Social Security
number.
0 ∅
1 025-612-0001
2 981-101-0002
3 ∅
4 451-229-0004
…

16
Hash Functions and Hash Table
s
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 (called table) of size N
When implementing a map with a hash table, the goal
is to store item (k, o) at index i = h(k)
17
SSN EXAMPLE

We design a hash table for 0 ∅

a map storing entries as 1 025-612-0001

2 981-101-0002
(SSN, Name), where SSN 3 ∅
(social security number) is a 4 451-229-0004

nine-digit positive integer

…
Our hash table uses an 9997 ∅

array of size N = 10,000 and 9998 200-751-9998

9999 ∅
the hash function
h(x) = last four digits of x

18
Hash Functions

A hash function is The hash code is

usually specified as the applied first, and the
compression function
composition of two
is applied next on the
functions: result, i.e.,
Hash code: h(x) = h2(h1(x))
h1: keys → integers The goal of the hash
Compression function: function is to “disper
se” the keys in an ap
h2: integers → [0, N − 1]
parently random way
19
Hash Codes
Memory address:
We reinterpret the memory a
ddress of the key object as a
n integer Good in general, ex
cept for numeric and string ke
ys
Integer cast:
We reinterpret the bits of the
key as an integer
Suitable for keys of length les
s than or equal to the number
of bits of the integer
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
20
Hash Codes (cont.)
Polynomial accumulation:
We partition the bits of the key
into a sequence of
components of fixed length
(e.g., 8, 16 or 32 bits)
a0 a1 … an−1
We evaluate the polynomial
p(z) = a0 + a1 z + a2 z2 + …
… + an−1zn−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
p0(z) = an−1
pi (z) = an−i−1 + zpi−1(z)
(i = 1, 2, …, n −1)
We have p(z) = pn−1(z)
21
Compression Functions

Division: Multiply, Add and

h2 (y) = y mod N Divide (MAD):
The size N of the h2 (y) = (ay + b) mod N
hash table is usually a and b are
chosen to be a prime nonnegative integers
The reason has to do such that
with number theory a mod N ≠ 0
and is beyond the Otherwise, every
scope of this course integer would map to
the same value b
22
ABSTRACT HASH TABLE CLASS

23
Collision Handling

Collisions occur when 0 ∅

1 025-612-0001
different elements are 2 ∅
mapped to the same 3 ∅
4 451-229-0004 981-101-0004
cell
Separate Chaining: let
Separate chaining is
each cell in the table
simple, but requires
point to a linked list of
additional memory
entries that map there
outside the table

24
MAP WITH SEPARATE CHAINING

Delegate operations to a list-based map at each cell:

Algorithm get(k):
return A[h(k)].get(k)

Algorithm put(k,v):
t = A[h(k)].put(k,v)
if t = null then {k is a new key}
n=n+1
return t

Algorithm remove(k):
t = A[h(k)].remove(k)
if t ≠ null then {k was found}
n=n-1
return t
25
HASH TABLE WITH SEPARATE CHAINING

26
Linear Probing

Open addressing: the Example:

colliding item is placed in a
different cell of the table
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”
h(x) = x mod 13
Insert keys 18, 41,
22, 44, 59, 32, 31, 73,
in this order
0 1 2 3 4 5 6 7 8 9 10 11 12

Colliding items lump together,

causing future collisions to 41 18 44 59 32 22 31 73
cause a longer sequence of 0 1 2 3 4 5 6 7 8 9 10 11 12
probes
27
Search with Linear Probing

Consider a hash table Algorithm get(k)

i ← h(k)
A that uses linear
p←0
probing repeat
get(k) c ← A[i]
if c = ∅
We start at cell h(k)
return null
We probe consecutive else if c.getKey () = k
locations until one of the return c.getValue()
following occurs else
An item with key k is i ← (i + 1) mod N
found, or p←p+1
An empty cell is found, until p = N
or return null
N cells have been
28
Updates with Linear Probing
To handle insertions and d
eletions, we introduce a sp
ecial object, called AVAIL
ABLE, which replaces dele
ted elements
remove(k)
We search for an entry with
key k
If such an entry (k, o) is fo
und, we replace it with the
special item AVAILABLE a
nd we return element o
Else, we return null
put(k, o)
We throw an exception if t
he table is full
We start at cell h(k)
We probe consecutive cell
s until one of the following
occurs
A cell i is found that is eith
er empty or stores AVAILA
BLE, or
N cells have been unsucce
ssfully probed
We store (k, o) in cell i
29
Hash Table with Linear Probing

30
Double Hashing

Double hashing uses a

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

31
EXAMPLE OF DOUBLE HASHING

k h (k ) d (k ) Probes
Consider a hash 18 5 3 5
table storing integer 41 2 1 2
22 9 6 9
keys that handles 44 5 5 5 10
59 7 4 7
collision with double 32 6 3 6
hashing 31
73
5
8
4
4
5
8
9 0

N = 13
h(k) = k mod 13
0 1 2 3 4 5 6 7 8 9 10 11 12
d(k) = 7 − k mod 7
Insert keys 18, 41,
31 41 18 32 59 73 22 44
22, 44, 59, 32, 31, 73, 0 1 2 3 4 5 6 7 8 9 10 11 12
in this order
32
Performance of Hashing
In the worst case, searches,
insertions and removals on a
hash table take O(n) time
The worst case occurs when
all the keys inserted into the
map collide
The load factor α = n/N
affects the performance of a
hash table
Assuming that the hash
values are like random
numbers, it can be shown
that the expected number of
probes for an insertion with
open addressing is
1 / (1 − α)
The expected running
time of all the dictionary
ADT operations in a
hash table is O(1)
In practice, hashing is
very fast provided the
load factor is not close
to 100%
Applications of hash
tables:
small databases
compilers
browser caches
33