Open addressing schemes are determined by the type of the probe sequence, and the replacement strategy for resolving the collisions. Some of the commonly used probe sequences are:

Random and uniform probings are, in some sense, the idealized models [89,97], and their plausible performances are among the easiest to analyze; but obviously they are unrealistic. Linear probing is perhaps the simplest to implement, but it behaves badly when the table is almost full. Double probing can be seen as a compromise.

During the insertion process of a key x, suppose that we arrive at the cell $f_i\left(x\right)$ which is already occupied by another previously inserted key y, that is, $f_i\left(x\right)=f_j\left(y\right)$, for some $j\in \mathbb{N}$. Then a replacement strategy for resolving the collision is needed. Three strategies have been suggested in the literature (see [68] for other methods):

Evidently, the performance of any open addressing scheme deteriorates when the ratio $m/n$ approaches 1, as the cluster sizes increase, where a cluster is an isolated set of consecutively occupied cells (cyclically defined) that are bounded by empty cells. Therefore, we shall assume that the hash table is $\alpha$-full, that is, the number of hashed keys $m=⌊\alpha n⌋$, where $\alpha \in (0,1)$ is a constant called the load factor. The asymptotic average-case performance has been extensively analyzed for random and uniform probing [9,55,67,75,89,97], linear probing [50,51,54,61], and double probing [6,43,57,84,86]. The expected search times were proven to be constants, more or less, depending on $\alpha$ only. Recent results about the average-case performance of linear probing, and the limit distribution of the construction time have appeared in [32,52,91]. See also [3,39,76] for the average-case analysis of linear probing for nonuniform hash functions.

It is worth noting that the average search time of linear probing is independent of the replacement strategy; see [51,75]. This is because the insertion of any order of the keys results in the same set of occupied cells, i.e., the cluster sizes are the same; and hence, the total displacement of the keys—from their initial hashing locations—remains unchanged. It is not difficult to see that this independence is also true for random and double probings. That is, the replacement strategy does not have any effect on the average successful search time in any of the above probings. In addition, since in linear probing the unsuccessful search time is related to the cluster sizes (unlike random and double probings), the expected and the maximum unsuccessful search times in linear probing are invariant to the replacement strategy.

It is known that lcfs [78,79] and robin hood [13,14,68,91] strategies minimize the variance of displacement. Recently, Janson [45] and Viola [90] have reaffirmed the effect of these replacement strategies on the individual search times in linear probing hashing.

The focal point of this article, however, is the worst-case search time which is proportional to the length of the longest probe sequence over all keys (llps, for short). Many results have been established regarding the worst-case performance of open addressing.

The worst-case performance of linear probing with fcfs policy was analyzed by Pittel [77]. He proved that the maximum cluster size, and hence the llps needed to insert (or search for) a key, is asymptotic to ${(\alpha -1-log\alpha )}^{-1}logn$, in probability. As we mentioned above, this bound holds for linear probing with any replacement strategy. Chassaing and Louchard [15] studied the threshold of emergence of a giant cluster in linear probing. They showed that when the number of keys $m=n-\omega \left(\sqrt{n}\right)$, the size of the largest cluster is $o\left(n\right)$, w.h.p.; however, when $m=n-o\left(\sqrt{n}\right)$, a giant cluster of size $\mathrm{\Theta }\left(n\right)$ emerges, w.h.p.

Gonnet [40] proved that with uniform probing and fcfs replacement strategy, the expected llps is asymptotic to ${log}_{1/\alpha }n-{log}_{1/\alpha }{log}_{1/\alpha }n+O\left(1\right)$, for $\alpha$-full tables. However, Poblete and Munro [78,79] showed that if random probing is combined with lcfs policy, then the expected llps is at most $(1+o\left(1\right)){\mathrm{\Gamma }}^{-1}\left(\alpha n\right)=O(logn/loglogn)$, where $\mathrm{\Gamma }$ is the gamma function.

On the other hand, the robin hood strategy with random probing leads to a more striking performance. Celis [13] first proved that the expected llps is $O(logn)$. However, Devroye, Morin and Viola [22] tightened the bounds and revealed that the llps is indeed ${log}_{2}logn\pm \mathrm{\Theta }\left(1\right)$, w.h.p., thus achieving a double logarithmic worst-case insertion and search times for the first time in open addressing hashing. Unfortunately, one cannot ignore the assumption in random probing about the availability of an infinite collection of hash functions that are sufficiently independent and behave like truly uniform hash functions in practice. On the other side of the spectrum, we already know that robin hood policy does not affect the maximum unsuccessful search time in linear probing. However, robin hood may be promising with double probing.

Open addressing methods that rely on rearrangement of keys were under investigation for many years, see, e.g., [10,42,58,60,68,82]. Pagh and Rodler [74] studied a scheme called cuckoo hashing that exploits the lcfs replacement policy. It uses two hash tables of size $n>(1+ϵ)m$, for some constant $ϵ>0$; and two independent hash functions chosen from an $O(logn)$-universal class—one function only for each table. Each key is hashed initially by the first function to a cell in the first table. If the cell is full, then the new key is inserted there anyway, and the old key is kicked out to the second table to be hashed by the second function. The same rule is applied in the second table. Keys are moved back and forth until a key moves to an empty location or a limit has been reached. If the limit is reached, new independent hash functions are chosen, and the tables are rehashed. The worst-case search time is at most two, and the amortized expected insertion time, nonetheless, is constant. However, this scheme utilizes less than 50% of the allocated memory, has a worst-case insertion time of $O(logn)$, w.h.p., and depends on a wealthy source of provably good independent hash functions for the rehashing process. For further details see [21,26,33,70].

The space efficiency of cuckoo hashing is significantly improved when the hash table is divided into blocks of fixed size $b\ge 1$ and more hash functions are used to choose $k\ge 2$ blocks for each key where each is inserted into a cell in one of its chosen blocks using the cuckoo random walk insertion method [25,34,35,37,56,95]. For example, it is known [25,56] that 89.7% space utilization can be achieved when $k=2$ and the hash table is partitioned into non-overlapping blocks of size $b=2$. On the other hand, when the blocks are allowed to overlap, the space utilization improves to 96.5% [56,95]. The worst-case insertion time of this generalized cuckoo hashing scheme, however, is proven [35,38] to be polylogarithmic, w.h.p.

Many real-time static and dynamic perfect hashing schemes achieving constant worst-case search time, and linear (in the table size) construction time and space were designed in [11,23,24,27,28,36,71,72]. All of these schemes, which are based, more or less, on the idea of multilevel hashing, employ more than a constant number of perfect hash functions chosen from an efficient universal class. Some of them even use $O\left(n\right)$ functions.

In the next section, we recall some of the useful results about the greedy multiple-choice paradigm. We prove, in Section 3, a universal lower bound of order of $loglogn$ on the maximum unsuccessful search time of any two-way linear probing algorithm. We prove, in addition, that not every two-way linear probing scheme behaves efficiently. We devote Section 4 to the positive results, where we present our two two-way linear probing heuristics that accomplish $O(loglogn)$ worst-case unsuccessful search time. Simulation results of the studied algorithms are summarized in Section 5.

Throughout, we assume the following. We are given m keys—from a universe set of keys $\mathcal{U}$—to be hashed into a hash table of size n such that each cell contains at most one key. The process of hashing is sequential and on-line, that is, we never know anything about the future keys. The constant $\alpha \in (0,1)$ is preserved in this article for the load factor of the hash table, that is, we assume that $m=⌊\alpha n⌋$. The n cells of the hash table are numbered $0,\dots ,n-1$. The linear probe sequences always move cyclically from left to right of the hash table. The replacement strategy of all of the introduced algorithms is fcfs. The insertion time is defined to be the number of probes the algorithm performs to insert a key. Similarly, the search time is defined to be the number of probes needed to find a key, or two empty cells in the case of unsuccessful search. Observe that unlike classical linear probing, the insertion time of two-way linear probing may not be equal to the successful search time. However, they are both bounded by the unsuccessful search time. Notice also that we ignore the time to compute the hash functions.

Let $\beta =⌊b{log}_{a}n⌋$ for some positive constants a and b to be defined later, and without loss of generality, assume that $N:=n/\beta$ is an integer. Suppose that the hash table is divided into N disjoint blocks, each of size $\beta$. For $i\in \left[\left[N\right]\right]$, let ${\mathfrak{B}}_i=\left\{\beta (i-1)+1,\dots ,\beta i\right\}$ be the set of cells of the i-th block, where we consider the cell numbers in a circular fashion. We say that a cell $j\in \left[\left[n\right]\right]$ is “covered" if there is a key whose first initial hashing cell is the cell j and its second initial hashing cell is an occupied cell. A block is covered if all of its cells are covered. Observe that if a block is covered then it is fully occupied. Thus, it suffices to show that there would be a covered block, w.h.p.

For $i\in \left[\left[N\right]\right]$, let $Y_i$ be the indicator that the i-th block is covered. The random variables $Y_1,\dots ,Y_N$ are negatively associated which can been seen as follows. For $j\in \left[\left[n\right]\right]$ and $t\in \left[\left[m\right]\right]$, let $X_j\left(t\right)$ be the indicator that the j-th cell is covered by the t-th key, and set $X_0\left(t\right):=1-{\sum }_{j=1}^n{X}_j\left(t\right)$. Notice that the random variable $X_0\left(t\right)$ is binary. The zero-one Lemma asserts that the binary random variables $X_0\left(t\right),\dots ,X_n\left(t\right)$ are negatively associated. However, since the keys choose their initial hashing cells independently, the random variables $X_0\left(t\right),\dots ,X_n\left(t\right)$ are mutually independent from the random variables $X_0\left(t^{\prime }\right),\dots ,X_n\left(t^{\prime }\right)$, for any distinct $t,t^{\prime }\in \left[\left[m\right]\right]$. Thus, by Lemma 2, the union ${\cup }_{t=1}^m\left\{X_0\left(t\right),\dots ,X_n\left(t\right)\right\}$ is a set of negatively associated random variables. The negative association of the $Y_i$ is assured now by Lemma 3 as they can be written as non-decreasing functions of disjoint subsets of the indicators $X_j\left(t\right)$. Since the $Y_i$ are negatively associated and identically distributed, then Thus, we only need to show that $N\mathbb{P}\left\{Y_1=1\right\}$ tends to infinity as n goes to infinity. To bound the last probability, we need to focus on the way the first block ${\mathfrak{B}}_1=\left\{1,2,\dots ,\beta \right\}$ is covered. For $j\in \left[\left[n\right]\right]$, let $t_j$ be the smallest $t\in \left[\left[m\right]\right]$ such that $X_j\left(t\right)=1$ (if such exists), and $m+1$ otherwise. We say that the first block is “covered in order" if and only if $1\le t_1<t_2<\cdots <t_{\beta }\le m$. Since there are $\beta !$ orderings of the cells in which they can be covered (for the first time), we have For $t\in \left[\left[m\right]\right]$, let $M\left(t\right)=1$ if block ${\mathfrak{B}}_1$ is full before the insertion of the t-th key, and otherwise be the minimum $i\in {\mathfrak{B}}_1$ such that the cell i has not been covered yet. Let A be the event that, for all $t\in \left[\left[m\right]\right]$, the first initial hashing cell of the t-th key is either cell $M\left(t\right)$ or a cell outside ${\mathfrak{B}}_1$. Define the random variable $W:={\sum }_{t=1}^m{W}_t$, where $W_t$ is the indicator that the t-th key covers a cell in ${\mathfrak{B}}_1$. Clearly, if A is true and $W\ge \beta$, then the first block is covered in order. Thus, However, since the initial hashing cells are chosen independently and uniformly at random, then for n chosen large enough, we have and for $t\ge ⌈m/2⌉$, Therefore, for n sufficiently large, we get which goes to infinity as n approaches infinity whenever $a=8e^2/{\alpha }^2$ and b is any positive constant less than 1. □

Clearly, algorithms ShortSeq$(n,m)$ and SmallCluster$(n,m)$ satisfy the condition of Theorem 7. So this corollary follows.

We define for each key t a full history tree $T_t$ that describes essentially the history of the block that contains the t-th key up to its insertion time. It is a colored binary tree that is labelled by key numbers except possibly the leaves, where each key refers to the block that contains it. Thus, it is indeed a binary tree that represents all the pairs of blocks available for all other keys upon which the final position of the key t relies. Formally, we construct the binary tree node by node in Breadth-First-Search (bfs) order as follows. First, the root of $T_t$ is labelled t, and is colored white. Any white node labelled $\tau$ gets two children: a left child corresponding to the block $X_{\tau }$, and a right child corresponding to the block $Y_{\tau }$. The left child is labelled and colored according to the following rules:

Next, the right child of $\tau$ is labelled and colored by following the same rules but with the block $Y_{\tau }$. We continue processing nodes in bfs fashion. A black or gray node in the tree is a leaf and is not processed any further. A white node with label $\sigma$ is processed in the same way we processed the key $\tau$, but with its two blocks $X_{\sigma }$ and $Y_{\sigma }$. We continue recursively constructing the tree until all the leaves are black or gray. See Figure 6 for an example of a full history tree.

Notice that the full history tree is totally deterministic as it does not contain any random value. It is also clear that the full history tree contains at least one gray leaf and every internal (white) node in the tree has two children. Furthermore, since the insertion process is sequential, node values (key numbers) along any path down from the root must be decreasing (so the binary tree has the heap property), because any non-gray child of any node represents the last key inserted in the block containing it at the insertion time of the parent. We will not use the heap property however.

Clearly, the full history tree permits one to deduce the load of the block that contains the root key at the time of its insertion: it is the length of the shortest path from the root to any gray node. Thus, if the block’s load is more than h, then all gray nodes must be at distance more than h from the root. This leads to the notion of a truncated history tree of height h, that is, with $h+1$ levels of nodes. The top part of the full history tree that includes all nodes at the first $h+1$ levels is copied, and the remainder is truncated.

We are in particular interested in truncated history trees without gray nodes. Thus, by the property mentioned above, the length of the shortest path from the root to any gray node (and as noted above, there is at least one such node) would have to be at least $h+1$, and therefore, the load of the block harboring the root’s key would have to be at least $h+1$. More generally, if the load is at least $h+\xi$ for a positive integer $\xi$, then all nodes at the bottom level of the truncated history tree that are not black nodes (and there is at least one such node) must be white nodes whose children represent keys that belong to blocks with load of at least $\xi$ at their insertion time. We redraw these node as boxes to denote the fact that they represent blocks of load at least $\xi$, and we call them “block" nodes.

Let $\xi \in \mathbb{N}$ be a fixed integer to be picked later. For positive integers h and k, where $h+\xi \le k\le m$, a witness tree$W_k\left(h\right)$ is a truncated history tree of a key in the set $\left[\left[k\right]\right]$, with $h+1$ levels of nodes (thus, of height h) and with two types of leaf nodes, black nodes and “block" nodes. This means that each internal node has two children, and the node labels belong to the set $\left[\left[k\right]\right]$. Each black leaf has a label of an internal node that precedes it in bfs order. Block nodes are unlabelled nodes that represent blocks with load of at least $\xi$. Block nodes must all be at the furthest level from the root, and there is at least one such node in a witness tree. Notice that every witness tree is deterministic. An example of a witness tree is shown in Figure 7.

Let ${\mathcal{W}}_k(h,w,b)$ denote the class of all witness trees $W_k\left(h\right)$ of height h that have $w\ge 1$ white (internal) nodes, and $b\le w$ black nodes (and thus $w-b+1$ block nodes). Notice that, by definition, the class ${\mathcal{W}}_k(h,w,b)$ could be empty, e.g., if $w<h$, or $w\ge 2^h$. However, $|{\mathcal{W}}_k(h,w,b)|\le 4^w{2}^{w+1}{w}^b{k}^w$, which is due to the following. Without the labelling, there are at most $4^w$ different shape binary trees, because the shape is determined by the w internal nodes, and hence, the number of trees is the Catalan number $\left(\genfrac{}{}{0pt}{}{2w}{w}\right)/(w+1)\le 4^w$. Having fixed the shape, each of the leaves is of one of two types. Each black leaf can receive one of the w white node labels. Each of the white nodes gets one of k possible labels.

Note that, unlike the full history tree, not every key has a witness tree $W_k\left(h\right)$: the key must be placed into a block of load of at least $h+\xi -1$ just before the insertion time. We say that a witness tree $W_k\left(h\right)$ occurs, if upon execution of algorithm WalkFirst, the random choices available for the keys represented by the witness tree are actually as indicated in the witness tree itself. Thus, a witness tree of height h exists if and only if there is a key that is inserted into a block of load of at least $h+\xi -1$ before the insertion.

Before we embark on the proof of Theorem 10, we highlight three important facts whose proofs are provided in Appendix A. First, we bound the probability that a valid witness tree occurs.

The next lemma asserts that the event D in Lemma 4 is most likely to be true, for sufficiently large $\xi <{\beta }_3$.

Lemma 6 addresses a simple but crucial fact. If the height of a witness tree $W_k\left(h\right)\in {\mathcal{W}}_k(h,w,b)$ is $h\ge 2$, then the number of white nodes w is at least two, (namely, the root and its left child); but what can we say about b, the number of black nodes?