### CS201 - Spring 2014 - Class 30

• exercise

• storing data for quick lookup:
- support three key operations:
- insert
- search/contains
- remove

- key idea:
- use an array to store the data
- associate with each data item an index in the array

1. generate a numerical representation for the data item

2. take numerical representation (hash code) and map it to an entry in the array

3. handle collisions

• collision resolution by chaining

- because of some of the cons above (in particular the overhead), we often only want to use a basic array to store the hashtable
- we still have to do something about collisions... ideas?
- when we have a collision and there's already an item at that location, we need to find another possible place to put it
- for open addressing, we must define a "probe sequence" that determines where to look in the table next if we have a collision
- if h(x) is the hash function, the probe sequence is often written as h(x, i), that is the ith place to look if all i-1 previous locations were full already
- h(x, 0) is the first place to check
- h(x, 1) the next
- and so on
- notice that this is defined by the hash function, so it could be different for different items, etc.
- the probe sequence must be a permutation of all of the entries in the table, that is, if we look at h(x, 0), h(x, 1), ..., h(x, m-1), these values will be a permutation of 0, 1, ..., m-1
- why?
- inserting
- given this, how can we insert items into the table?
- start at probe sequence 0, if it's empty put the item there
- if it's full, go on to 1, etc.
- note that we can actually fill up the table here
- contains
- what do we need to check here?
- again, start at probe 0
- see if there's something there AND see if the item is equal to the item we're actually looking for
- if not, keep looking
- when do we stop?
- when we find an empty entry
- look at OpenAddressedHashtable class in Hashtables code
- what is the "put" method doing?
- write the "contains" method
- notice that the class is abstract since we haven't defined what the probe sequence will be

• abstract methods/classes

• probe sequences
- our one requirement is that the probe sequence must visit every entry in the table
- ideas?
- linear probing
- easiest to understand:
- h(k, i) = (h(k) + i) % m
- just look at the next location in the hash table
- if the original hash function says to look at location i and it's full then, we look at i+1, i+2, i+3, ...
- need to modulo the size of the table to wrap around
- look at LinearAddressedHashtable class in Hashtables code
- problems?
- "primary clustering"
- you tend to get very long sequences of things clustered together
- show an example
- double hashing
- h(x, i) = (h(x) + i h2(x)) % m
- unlike linear, where the offset is constant, the offset this time is another hash of the data
- avoids primary clustering
- what is the challenge?
- probe sequence must be a permutation of the data
- h2 must visit all possible positions in the data
- most commonly used in real implementation

• running time for open addressing
- what is the run-time for contains for open addressing?
- again, assume an ideal hash function where each original location is equally likely and also each probe is equally likely
- assuming n things in the table and m elements (i.e. a load of alpha)
- what is the probability that the first place we look is occupied?
- alpha (n/m)
- given the first was occupied, what is the probability that the second place we look is occupied?
- alpha (actually, (n-1)/(m-1), but almost alpha :)
- what is the probability that we have to make a third probe?
- alpha (the first position was occupied) +
- alpha * alpha (the second position was occupied)
- so, what is the probability that we have to probe i positions before we find an open one?
- it's the sum of the probabilities that we have to make each probe
- alpha + alpha^2 + alpha^3 + ... + alpha^{i-1}
- which is bounded by: 1/(1-alpha)
- how does this help us with our run-time?
- the run-time is bounded by the number of probes we have to make
- to insert, we need to find an open entry, what is the running time?
O(1 + 1/(1-alpha))
- for contains, we may have to search until we find an open entry, what's the running time?
O(1 + 1/(1-alpha))
- what does this translate to search-wise?
alpha   average number of searches
0.1   1.11
0.25   1.33
0.5   2
0.75   4
0.9   10
0.95   20
0.99   100
(note that these are ideal case numbers)