250 COMP Winter 2010
26 - hashing
March 17, 2010
Today we look at a particular kind of map, sometimes called a hash map. (Java has a class
HashMap for representing these kinds of maps.) Before we understand what a hash map is, though,
we need to understand what hashing is. [Note: make sure you also read through the slides. There
are many gures in the slides which I have not reproduced here and which illustrate the various
maps discussed in this lecture.]
Hashing
Suppose you have a set of keys K . Dene a hash function to be a mapping:
h : K {0, 1, 2, m 1}
where m is some positive integer. Specically, for each key k K , the hash function species some
integer h(k ). For hash functions, typically m is smaller than the number of keys in K . For example,
if the keys are possible social insurance numbers (109 of them), then we might let m be 1000, rather
than 109 . So it happens alot that two keys in K to map to the same integer. Also note that the
hash function h is a mapping that is dened on the entire set K and not just on a subset of K .
(The denition of mapping last class allowed a mapping to only include a subset of keys.).
It is very common to design hash functions by writing them as a composition of two maps. The
rst map takes keys K to a large set of integers. The second map takes the large set of integers to a
small set of integers {0, 1, . . . , m 1}. (The reasons for this will be clear by the end of the lecture.)
The rst mapping is called hash coding and the integer chosen for a key k is called the hash code
for that key. The second mapping is called compression. Compression maps the hash codes to hash
values.
In fact, we saw two examples of hash codes last lecture. The keyObject-to-address map, and
the string-to-integer map (see lecture 26 page 3).
A typical compression function is the modulus function. e.g. suppose i is the hash code for
some key k (or the keys K are already integers). Then, the hash value is i mod m. Often one takes
m to be a prime number, though this is not necessary.
To summarize, we have that a hash function is typically composed of two functions:
h : {keys} {hash codes} {hash values},
i.e. the values {0, 1, . . . , m 1} are the hash values.
Hash map
Lets return to the problem we discussed last class in which we have a keys K and values V and
we wish to represent a map M which contains some set of ordered pairs (k, v ). We now wish to use
a hash function described above to represent this map. We assume the keys in the map M form a
relatively small subset of K .
[ASIDE: The values v V of the map M should not be confused with the hash values which
are are integers in 0, 1, . . . , m 1. The values v might be Employee records, or entries in an telephone
book, for example.]
Dene an array called a hash table, which will hold the (k, v ) pairs. This is like the direct
mapping array we discussed last lecture, except that it has far fewer slots than the number of keys
1
COMP 250 Winter 2010
26 - hashing
March 17, 2010
in our key space K , namely the number of slots in the array is typically just a bit bigger than the
number of (k, v ) pairs. Even if we make the number of slots m to be a bit bigger than the number
of pairs in the map, it could still happen that there are two keys k1 and k2 that hash to the same
hash value, that is, there is an index i in the array such that h(k ) = i for more than one key in the
map. this When happens, we say that a collision has occured. This can happen either if two keys
have the same hash code or if two keys have a dierent hash code but the compression function
maps them to the same slot e.g. 7 mod 5 = 22 mod 5 = 2.
To allow for collisions, we can use linked list of pairs (k, v ) at each slot of our hash table array.
The entries of a hash table, which now can hold multiple (k, v ) pairs, are called buckets or slots.
Storing a list of (k, v ) pairs in each hash bucket is called chaining.
Note that we need to store the key k because when use a key k to try to access a value v , we
need to know which of the v s stored in a bucket corresponds to which k . When we use a (search)
key k to nd a value v , we match the search key k with the keys in the bucket. For example, with
social insurance numbers (keys) and employee records (values), there may be multiple employee
records stored in each bucket and we need to be able to check which if any corresponds to the given
social insurance number.
hash table
key
value
In the worst case that all the elements in the collection hash to the same location in the array,
then we have one linked list. This is undesirable since the whole point here is to represent a map
so that we can access values as quickly as possible. To avoid having such long lists, we would like
to choose a hash function so that there is roughly an equal chance of mapping to any of the hash
values. (The word hash means to chop/mix up.)
In class, several students asked if it is possible to design hash functions that avoid collisions
entirely. For this to be possible in any given situation, it is necessary (but not sucient) that the
number of buckets of the hash table be greater than or equal to the number of key-value pairs in
the map. Hash functions that are designed to avoid collisions are called perfect hash functions.
2
COMP 250 Winter 2010
26 - hashing
March 17, 2010
[ASIDE: There is one other term that comes up often: the load factor of a hash table is the
ratio of the number of (k, v ) pairs currently in the table to the number of slots in the table (m). In
Java, for example, the HashMap and HashSet classes implement hash functions, and the load factor
4
for the hash table is never more than 0.75m. That is, m is chosen to be at least 3 as great as the
number of elements: k-v pairs in the case of a HashMap, or set elements in the case of a HashSet. ]
hash codes for strings
Suppose s is a string, composed out of unicode characters (16 bits each). Dene its hash code to
be:
s.length1
s[i]
h(s) =
i=0
where s[i] is the 16-bit unicode value of the character at position i in the string. This will be an
integer at most s.length 216 . In this above example, two strings consisting of the same set of
characters, such as eat and ate will have the same hash code.
A more general hash code for strings can be dened by
s.length1
s[i] pi
h(s) =
i=0
where p is some positive integer. In the last lecture, I gave you a similar formula for the case p = 216 ,
which gave us unique hash codes i.e. no two strings mapped to the same hash code.
In Java, the hashCode() method for the String class is dened
s.length1
s[i] ps.lengthi1
h(s) =
i=0
with p = 31, and this formula is indeed stated in the Java API in the String.hashCode() method.
(Check it out,
http://java.sun.com/javase/6/docs/api/java/lang/String.html#hashCode() )
3