Hash Function in Separate Chaining Vs. Open Addressing

Question

I'm reading Weiss's Data Structures book, and I'm confused with the difference between hash function in Separate Chaining Vs. hash function in Open Addressing.

In separate chaining, the hash function is defined as:

hash(x) = x mod tableSize

whereas in open addressing:

h_i(x) = (hash(x) + f(i)) mod tableSize

where i is the number of trials and f(i) is the function such as f(i) = i for Linear Probing, f(i) = i^2 for Quadratic Probing, etc.

I have 2 questions:

1) In Separate Chaining, does it make sense to have a hash function:

hash(x) = x mod 10

when the table size equals, let's say, 11?

2) In Open Addressing, do we always have to mod the key(+gap) by tableSize twice?

Answer 1

1) Not really. It will be correct, but not efficient. If you mod by less than the table size, there will be at least one bucket unused at the top of your table. If there is a specific reason to choose that value to mod by (there might be, if you're looking for certain properties) then you could just trim the table to that size and avoid the waste.

2) That isn't really necessary ( ((a mod c) + b) mod c is redundant) and that isn't the only definition in the first place. Slightly more generally you have h_i(x) = f(x, i) mod tableSize , some obvious choices for f include

• f(x, i) = x + i (linear probing)
• f(x, i) = x + a * i + b * i * i for some constants a and b != 0 (quadratic probing)
• f(x, i) = h1(x) + i * h2(x) for some suitable hash functions h1 and h2 (double hashing)

That last one is especially susceptible to overflow, which could mess up some properties, so you might want to perform some calculations modulo the table size (especially if that's a prime number, because then you have a nice field to work in).

Also, you're always going to use f(x, i) mod tablesize before you need f(x, i + 1) , so you might as well calculate f incrementally, where at every step you mod by the tablesize because you have to do it anyway.

But we're certainly not limited to those forms of f or indeed to this scheme of open addressing where we search for an open spot. Cuckoo hashing (and variants) has two candidate places to insert an item, and will kick out an item and move it to its alt-location (possibly also displacing an item) if both places are full (with some care taken to avoid infinite loops). That way a lookup only has two places to look at, instead of potentially the entire table. It has many variants.