Hash Tables - Motivation

• Consider the problem of storing several

(key, value) pairs in a data structure that would
support the following operations efficiently
– Insert(key, value)
– Delete(key, value)
– Find(key)

• Data Structures we have looked at so far

– Search Trees (BST, AVL, Splay) – all ops O(logN)
– Btree – all ops O(height)

Can we make Find/Insert/Delete all O(1)?

1
 Hash Tables
A hash table is a data structure that implements an
array abstract data type, a structure that can map
keys to values.

A hash function is used to compute an index (hash

code) into an array of slots.

During lookup, the key is hashed and the resulting

value is used as an index in the table.

Access of data becomes very fast if index of the

desired data is known.

2
 Hash Tables – Main Idea
• Main idea: Use the key (string or number) to
index directly into an array – O(1) time to
access records Hash Table. N = 11
0
45 1
// Returns the index of 2
45 // the key in the table 3 3
3 int HashFunction(int key){
16 4
20 return key%N;
42 16 5
} //end-HashFunction
6
• Keys 20 & 42 both map 7
to the same slot – 9 8

• Called a collision! 20 42? 9

10
• Need to handle collisions 3
 Hash Tables – String Keys
• If the keys are strings,
then convert them to an
integer index Hash Table. N = 11
cem 0
1
// Returns the index of 2
cem
// the key in the table 3
ali
int HashFunc(char key[]){ veli 4
veli
hasan ?????????
5
} //end-HashFunc
6
ali 7
8
hasan 9
10 4
 Hash Functions for String Keys
• If keys are strings, can get an integer by
adding up ASCII values of characters in key

// Returns the index of Problems?

// the key in the table
1. Will map “abc” and
int HashFunction(String key){
int hashCode = 0;
“bac” to the same slot!
int len = key.length();
2. If all keys are 8 or less
for (int i=0; i<len; i++){
characters long, then
hashCode += key.charAt(i); will map only to
} //end-for positions 0 through
8*127 = 1016
return hashCode % N; • Need to evenly
} //end-HashFunction distribute keys
5
 Hash Functions for String Keys
• Problems with adding up char values for string keys
1. If string keys are short, will not hash to all of the hash table
2. Different character combinations hash to same value
– “abc”, “bca”, and “cab” all add up to 6

– Suppose keys can use any of 29 characters plus blank

– A good hash function for strings: treat characters as
digits in base 30 (using “a” = 1, “b” = 2, “c” = 3, ………
“z” = 29, “ “ (space) = 30)
– “abc” = 1*30^2 + 2*30^1 + 3 = 900+60+3=963
– “bca” = 2*30^2 + 3*30^1 + 1 = 1800+270+1=2071
– “cab” = 3*30^2 + 1*30^1 + 2 = 2700+30+2=2732

– Can use 32 instead of 30 and shift left by 5 bits for

faster multiplication
6
 Hash Functions for String Keys
• A good hash function for strings: treat
characters as digits in base 30
– Can use 32 instead of 30 and shift left by 5 bits
for faster multiplication
// Returns the index of the key in the table
int HashFunction(String key){
int hashCode = 0;
int len = key.length();

for (i=0; i<len; i++){

hashCode = (hashCode << 5) + key.charAt(i)-’a’;
} //end-for

return hashCode % N;
} //end-HashFunction
7
 Hash Table Size
• We need to make sure that Hash Table is big
enough for all keys and that it facilitates the
Hash Function’s job to evenly distribute the
keys
– What if TableSize is 10 and all keys end in 0?
• All keys would map to the same slot!

– Need to pick TableSize carefully

• typically, a prime number is chosen

8
Properties of Good Hash Functions
• Should be efficiently computable – O(1) time
• Should hash evenly throughout hash table
• Should utilize all slots in the table
• Should minimize collisions

9
 Collisions and their Resolution
• A collision occurs when two different keys hash to the
same value
– E.g. For TableSize = 17, the keys 18 and 35 hash to the same
value
– 18 mod 17 = 1 and 35 mod 17 = 1

• Cannot store both data records in the same slot in

array!

• Two different methods for collision resolution:

– Separate Chaining: Use data structure (such as a linked list)
to store multiple items that hash to the same slot

– Open addressing (or probing): search for empty slots using a

second function and store item in first empty slot that is
found
10
 Separate Chaining
# of keys occupying
• Each hash table cell holds a pointer to
the slot
a linked list of records with same hash
value (i, j, k in figure) nil
i k1 nil
• Collision: Insert item into linked list nil

j k2 k3 k4 nil
• To Find an item: compute hash value,
then do Find on linked list
nil

• Can use a linked-list for k k5 k6 nil

Find/Insert/Delete in linked list
nil

• Can also use BSTs: O(log N) time * Hash(k1) = i

instead of O(N). But lists are usually
small – not worth the overhead of * Hash(k2)=Hash(k3)=Hash(k4) = j

BSTs * Hash(k5)=Hash(k6)=k
11
 Example
• In-Class Example: Insert {18, 19, 20, 29, 30, 31}
into empty hash table with TableSize = 10 using
separate chaining

0 20 30 • 18%10=8
1 31 • 19%10=9
2 • 20%10=0
3 • 29%10=9
4 • 30%10=0
5 • 31%10=1
6
7
8 18
9 19 29
12
 Load Factor of a Hash Table
• Let N = number of items to be stored
• Load factor LF = N/TableSize
• Suppose TableSize = 2 and number of items N = 10
– LF = 5
• Suppose TableSize = 10 and number of items N = 2
– LF = 0.2
• Average length of chained list = LF
• Average time for accessing an item = O(1) + O(LF)
– Want LF to be close to 1 (i.e. TableSize ~N)
– But chaining continues to work for LF > 1

13
Collision Resolution by Open Addressing
• Linked lists can take up a lot of space…
• Open addressing (or probing): When collision occurs,
try alternative cells in the array until an empty cell is
found
• Given an item X, try cells h0(X), h1(X), h2(X), …, hi(X)
• hi(X) = (Hash(X) + F(i)) mod TableSize
• Define F(0) = 0
• F is the collision resolution function. Three
possibilities:
– Linear: F(i) = i
– Quadratic: F(i) = i^2
– Double Hashing: F(i) = i*Hash2(X)

14
 Open Addressing I: Linear Probing
• Main Idea: When collision occurs, scan down the
array one cell at a time looking for an empty cell

• hi(X) = (Hash(X) + i) mod TableSize (i = 0, 1, 2, …)

• Compute hash value and increment until free cell is

found

15
 Example
• In-Class Example: Insert {18, 19, 20, 29, 30, 31}
into empty hash table with TableSize = 10 using
linear probing:
• hi(X) = (Hash(X) + i) mod TableSize (i = 0, 1, 2, …)
0 20
1 29 • (29+1)%10=0 i=1 • (28+0)%10=8 i=0
2 30 • (29+2)%10=1 i=2 • (28+1)%10=9 i=1
3 31 • (30+0)%10=0 i=0 • (28+2)%10=0 i=2
4 28 • (30+1)%10=1 i=1 • (28+3)%10=1 i=3
5 • (30+2)%10=2 i=2 • (28+4)%10=2 i=4
6 • (31+0)%10=1 i=0 • (28+5)%10=3 i=5
7 • (31+1)%10=2 i=1 • (28+6)%10=4 i=6
8 18 • (31+2)%10=3 i=2
9 19
16
Load Factor Analysis of Linear Probing
• Recall: Load factor LF = N/TableSize

• Fraction of empty cells = 1 – LF

• Fraction cells we expect to probe = 1/(1- LF)

• Can show that expected number of probes for:

– Successful searches = O(1+1/(1- LF))
– Insertions and unsuccessful searches = O(1+1/(1- LF)^2)

• Keep LF <= 0.5 to keep number of probes small

(between 1 and 5). (E.g. What happens when LF = 0.99)

17
 Drawbacks of Linear Probing
• Works until array is full, but as number of items N
approaches TableSize (LF ~ 1), access time approaches
O(N)

• Very prone to cluster formation (as in our example)

– If key hashes into a cluster, finding free cell involves going
through the entire cluster
– Inserting this key at the end of cluster causes the cluster to
grow: future Inserts will be even more time consuming!
– This type of clustering is called Primary Clustering

• Can have cases where table is empty except for a few

clusters
– Does not satisfy good hash function criterion of distributing
keys uniformly

18
Open Addressing II: Quadratic Probing
• Main Idea: Spread out the search for an empty slot
Increment by i^2 instead of i
• hi(X) = (Hash(X) + i2) mod TableSize (i = 0, 1, 2, …)
– No primary clustering but secondary clustering possible

• Example 1: Insert {18, 19, 20, 29, 30, 31} into empty
hash table with TableSize = 10
• Example 2: Insert {1, 2, 5, 10, 17} with TableSize = 16

• Theorem: If TableSize is prime and LF < 0.5, quadratic

probing will always find an empty slot

19
 Example
• In-Class Example: Insert {18, 19, 20, 29, 30, 31}
into empty hash table with TableSize = 10 using
quadratic probing:
• hi(X) = (Hash(X) + i2) mod TableSize (i = 0, 1, 2, …)
0 20 • (29+0)%10=9 i=0
1 30 • (29+1)%10=0 i=1
2 31 • (29+4)%10=3 i=2
3 29 • (30+0)%10=0 i=0
4 • (30+1)%10=1 i=1
5 • (31+0)%10=1 i=0
6 • (31+1)%10=2 i=1
7
8 18
9 19
20
 Example
• In-Class Example: Insert {1, 2, 5, 10, 17} with
TableSize = 16 using quadratic probing:
• hi(X) = (Hash(X) + i2) mod TableSize (i = 0, 1, 2, …)
0
• (1+0)%16=1 i=0
1 1
• (2+0)%16=2 i=0
2 2
• (5+0)%16=5 i=0
3
• (10+0)%16=10 i=0
4
• (17+0)%16=1 i=0
5 5
• (17+1)%16=2 i=1
…
• (17+4)%16=5 i=2 Theorem: If TableSize is prime
10 10
• (17+9)%16=10 i=3 and LF < 0.5, quadratic
…
• (17+16)%16=1 i=4 probing will always find
15 an empty slot
• (17+25)%16=10 i=5

21
 Open Addressing III: Double Hashing
• Idea: Spread out the search for an empty slot by using
a second hash function
– No primary or secondary clustering

• hi(X) = (Hash(X) + i*Hash2(X)) mod TableSize for i =

0, 1, 2, …
• E.g. Hash2(X) = R – (X mod R)
– R is a prime smaller than TableSize

• Try this example: Insert {18, 19, 20, 29, 30, 31} into
empty hash table with TableSize = 10 and R = 7

• No clustering but slower than quadratic probing due to

Hash2
22
 Example
• In-Class Example: Insert {18, 19, 20, 29, 31, 28}
into empty hash table with TableSize = 10 and
R=7 using double hasing:
• hi(X) = (Hash(X) + i*Hash2(X)) mod TableSize for i = 0, 1, 2, …
• E.g. Hash2(X) = R – (X mod R)

0 20 • (29+0*hash2)%10=9 i=0
• Hash2(29)=7-(29%7)
• Hash2(29)=7-1=6
1 31 • (29+1*hash2(29))%10=5 i=1
2 28 • (31+0*hash2)%10=1 i=0
3 • (28+0*hash2)%10=8 i=0
4 • (28+1*hash2(28))%10=5 i=1
5 29 • (28+2*hash2(28))%10=2 i=2
6
7
8 18
9 19
23
 Lazy Deletion with Probing
• Need to use lazy deletion if we use probing
(why?)
– Think about how Find(X) would work…

• Mark array slots as “Active/Not Active”

• If table gets too full (LF ~ 1) or if many

deletions have occurred:
– Running time for Find etc. gets too long, and
– Inserts may fail!
– What do we do?

24
 Rehashing
• Rehashing – Allocate a larger hash table (of
size 2*TableSize) whenever LF exceeds a
particular value

• How does it work?

– Cannot just copy data from old table: Bigger table
has a new hash function
– Go through old hash table, ignoring items marked
deleted
– Recompute hash value for each non-deleted key and
put the item in new position in new table

• Running time = O(N)

– but happens very infrequently 25
 Applications of Hash Tables
• In Compilers: Used to keep track of declared
variables in source code – this hash table is
known as the “Symbol Table.”

• In storing information associated with

strings
– Example: Counting word frequencies in a text

• In on-line spell checkers

– Entire dictionary stored in a hash table
– Each word is text hashed – if not found, word is
misspelled.

26
 Hash Tables vs Search Trees
• Hash Tables are good if you would like to
perform ONLY Insert/Delete/Find

• Hash Tables are not good if you would also like

to get a sorted ordering of the keys
– Keys are stored arbitrarily in the Hash Table
• Hash Tables use more space than search trees
– Our rule of thumb: Time versus space tradeoff ☺

• Search Trees support

sort/predecessor/successor/min/max
operations, which cannot be supported by a
Hash Table
27