Open addressing, or closed hashing, is a method of collision resolution in hash tables. With this method a hash collision is resolved by probing, or searching through alternate locations in the array until either the target record is found, or an unused array slot is found, which indicates that there is no such key in the table. Well-known probe sequences include: ; Linear probing : in which the interval between probes is fixed — often set to 1. ; Quadratic probing : in which the interval between probes increases quadratically. ; Double hashing : in which the interval between probes is fixed for each record but is computed by another hash function. The main tradeoffs between these methods are that linear probing has the bestcache performance but is most sensitive to clustering, while double hashing has poor cache performance but exhibits virtually no clustering; quadratic probing falls in-between in both areas. Double hashing can also require more computation than other forms of probing. Some open addressing methods, such as Hopscotch hashing, Robin Hood hashing, last-come-first-served hashing and cuckoo hashing move existing keys around in the array to make room for the new key. This gives better maximum search times than the methods based on probing. A critical influence on performance of an open addressing hash table is the load factor; that is, the proportion of the slots in the array that are used. As the load factor increases towards 100%, the number of probes that may be required to find or insert a given key rises dramatically. Once the table becomes full, probing algorithms may even fail to terminate. Even with good hash functions, load factors are normally limited to 80%. A poor hash function can exhibit poor performance even at very low load factors by generating significant clustering, especially with the simplestlinear addressing method. Generally typical load factors with most open addressing methods are 50%, whilst separate chaining typically can use up to 100%. What causes hash functions to cluster is not well understood, and it is easy to unintentionally write a hash function that causes severe clustering.
The following pseudocode is an implementation of an open addressing hash table with linear probing and single-slot stepping, a common approach that is effective if the hash function is good. Each of the lookup, set and remove functions use a common internal functionfind_slot to locate the array slot that either does or should contain a given key. record pair varpair array slot function find_slot i := hash modulo num_slots // search until we either find the key, or find an empty slot. while and i = modulo num_slots return i function lookup i := find_slot if slot is occupied // key is in table return slot.value else// key is not in table return not found function set i := find_slot if slot is occupied // we found our key slot.value = value return if the table is almost full rebuild the table larger ' i = find_slot slot.key = key slot.value = value ; note 1 : Rebuilding the table requires allocating a larger array and recursively using the set operation to insert all the elements of the old array into the new larger array. It is common to increase the array sizeexponentially, for example by doubling the old array size. function remove i := find_slot if slot is unoccupied return // key is not in the table j := i loop mark slot as unoccupied r2: ' j := modulo num_slots if slot is unoccupied exit loop k := hash modulo num_slots // determine if k lies cyclically in ? &&) : ||) ) goto r2; slot := slot i := j ; note 2 : For all records in a cluster, there must be no vacant slots between their natural hash position and their current position. At this point in the pseudocode, is a vacant slot that might be invalidating this property for subsequent records in the cluster. is such a subsequent record. is the raw hash where the record at would naturally land in the hash table if there were no collisions. This test is asking if the record at is invalidly positioned with respect to the required properties of a cluster now that is vacant. Another technique for removal is simply to mark the slot as deleted. However this eventually requires rebuilding the table simply to remove deleted records. The methods above provide O updating and removal of existing records, with occasional rebuilding if the high-water mark of the table size grows. The O'' remove method above is only possible in linearly probed hash tables with single-slot stepping. In the case where many records are to be deleted in one operation, marking the slots for deletion and later rebuilding may be more efficient.
