Interpolation search

Using big-O notation, the performance of the interpolation algorithm on a data set of size n is O(n); however under the assumption of a uniform distribution of the data on the linear scale used for interpolation, the performance can be shown to be O(log log n). Dynamic interpolation search extends the o(log log n) bound to other distributions and also supports O(log n) insertion and deletion. Practical performance of interpolation search depends on whether the reduced number of probes is outweighed by the more complicated calculations needed for each probe. It can be useful for locating a record in a large sorted file on disk, where each probe involves a disk seek and is much slower than the interpolation arithmetic. Index structures like B-trees also reduce the number of disk accesses, and are more often used to index on-disk data in part because they can index many types of data and can be updated online. Still, interpolation search may be useful when one is forced to search certain sorted but unindexed on-disk datasets. ==Adaptation to different datasets==

When sort keys for a dataset are uniformly distributed numbers, linear interpolation is straightforward to implement and will find an index very near the sought value. On the other hand, for a phone book sorted by name, the straightforward approach to interpolation search does not apply. The same high-level principles can still apply, though: one can estimate a name's position in the phone book using the relative frequencies of letters in names and use that as a probe location. Some interpolation search implementations may not work as expected when a run of equal key values exists. The simplest implementation of interpolation search won't necessarily select the first (or last) element of such a run. ==Book-based searching==

The conversion of names in a telephone book to some sort of number clearly will not provide numbers having a uniform distribution (except via immense effort such as sorting the names and calling them name #1, name #2, etc.) and further, it is well known that some names are much more common than others (Smith, Jones,) Similarly with dictionaries, where there are many more words starting with some letters than others. Some publishers go to the effort of preparing marginal annotations or even cutting into the side of the pages to show markers for each letter so that at a glance a segmented interpolation can be performed. ==Sample implementation==

The following C++ code example is a simple implementation. At each stage it computes a probe position then as with the binary search, moves either the upper or lower bound in to define a smaller interval containing the sought value. Unlike the binary search which guarantees a halving of the interval's size with each stage, a misled interpolation may reduce/i-case efficiency of O(n). import ; import std; using std::vector; /* arr[low, high) is sorted, search the data "key" in this array, if "key" is found, return the corresponding index (NOT necessarily the highest possible index); if "key" is not found, just return low - 1 How to verify that the algorithm is correct? Proof: (finiteness: after one loop, the width of [low, high] decreases strictly ) Fist, high arr[high] scenario 4. when low high" will occur After one loop: case a1: "low" branch has been executed in this loop arr[middle] = arr[high] In the last loop, if "low" branch is executed, we know arr[low - 1] = arr[high] low = arr[high] low key): In the last loop, "low" must have been changed so we have arr[low - 1] arr[high]) In the last loop, "high" must have been changed so we have key static Rank interpolationSearch(vector& arr, const T& key, Rank low, Rank high) { high -= 1; int middle; int initialLow = low; while ((arr[low] static Rank interpolationSearch(vector& arr, const T& key, Rank low, Rank high) { high -= 1; assert(low Notice that having probed the list at index mid, for reasons of loop control administration, this code sets either high or low to be not mid but an adjacent index, which location is then probed during the next iteration. Since an adjacent entry's value will not be much different, the interpolation calculation is not much improved by this one step adjustment, at the cost of an additional reference to distant memory such as disk. Each iteration of the above code requires between five and six comparisons (the extra is due to the repetitions needed to distinguish the three states of and = via binary comparisons in the absence of a three-way comparison) plus some messy arithmetic, while the binary search algorithm can be written with one comparison per iteration and uses only trivial integer arithmetic. It would thereby search an array of a million elements with no more than twenty comparisons (involving accesses to slow memory where the array elements are stored); to beat that, the interpolation search, as written above, would be allowed no more than three iterations. ==See also==