A Example of hashing

A wonderful illustration of hashing is provided in Graham et al. (1994). Consider a data structure that consists of collection of key-value pairs. For example, a retailer might have a database of customers and store a number of data values for each customer. Imagine a key-value store (dictionary) where keys are names of customers and values are arbitrary arrays of customer-specific data. In practice, unique, randomly-generated customer identifiers would likely serve as keys; in a large database, the likelihood of naming collisions among customers becomes too high. Using customer names as keys, however, facilitates exposition.

As an example, consider locating a particular customer within the database, specifically assume that a total of I customers are recorded in the customer database. A naï ve implementation of storage and retrieval would involve maintaining a lookup table K(i) for each customer i∈1,…,I. Searching for data concerning specific customer i∗ would then involve the following steps:

1. Set i=1.

2. If i>I, stop and return “failure”.

3. If i=i∗, stop and return “success”.

4. Increase i by 1 and go back to step 1.

In the worst-case scenario, finding data concerning customer i involves (I+1) reads from the list of keys if one decides to traverse it in this fashion. In a real-world application, where I can easily be in billions, this method is too slow. Hashing was designed to speed up the process by storing the keys in J smaller lists.

Formally, a hash function\/ maps a key k≡K(i) into a list of numbers h(k) between 1 and J. In addition, two auxiliary tables are created, F(j) and N(i), where F(j) points to the first record in list j∈1,…,J, and N(i) points to the “next” record after record i in its list.

As an illustration, let J=4 based on the first letter of customer’s name as follows:

1. j=1 if first letter is between A and F,

2. j=2 if first letter is between G and L,

3. j=3 if first letter is between M and R, and

4. j=4 if first letter is between S and Z.

Before any data are recorded, set I=0. To formalize the notion of an empty list, set F(1)=F(2)=F(3)=F(4)=−1 In addition, set N(i)=0 to denote when i is the last entry in its list. Armed with these definitions, one can begin inserting data into this new structure.

Assume that the first customer who needs to be recorded is named Nora. The hash function defined above will insert Nora’s record into list j=3, since the first letter of her name, N, is between M and R. Now I=1, F(3)=1, and all other values of F and H are so far unchanged. Let the name of the second customer be Glenn. Inserting him into the database would change I to 2 and set F(2)=2, with no other changes. Now suppose that the third customer is named James. Adding him would result in I=3, and N(2)=3. With three records in the database the entire structure now looks as follows:

1. [–] Number of records: I=3, and number of hash buckets: J=4.

2. [–] Available keys: K(1)=Nora, K(2)=Glenn, K(3)=James.

3. [–] Indices of first records in each hash bucket: F(1)=−1, F(2)=2, F(3)=1, F(4)=−1.

4. [–] Indices of next records in each hash bucket after the first one: N(1)=0, N(2)=3, N(3)=0.

Fast-forwarding the example, assuming that 18 customer records were inserted into the database, things now looks like the following:

From this example, one can see that, in the worst-case, it would take six steps to locate the record using these four lists. With 18 total records this is a three-fold speed up in search and retrieval. In the average case, the time it takes to locate a record falls from (I/2) to (1/J); when I and J are large, this makes a big difference. A precise search algorithm for an entry i∗ would look as follows:

1. Set j=h(i∗) and i=F(j).

2. If i≤0, stop and return “failure”.

3. If K(i)=i∗, stop and return “success”.

4. Set j=i, set i=N(j), and return to step 2.

To locate Jennifer in the above example with 18 records, set j=2, since J is between G and L, and i=2, since Glenn is the first entry in the second list. Because Glenn is not Jennifer, update i to 3, since N(2)=3, that is, James is the next record in the second list after Glenn. Now, James is also not Jennifer, so i is updated to N(3). The exact value would be determined by when Jennifer was added to the database, but the important part is that now K(N(3))=i∗, that is, the search terminates successfully after three iterations.