在排序的数组中搜索，几乎没有比较

Question

You are given a std::vector<T> of distinct items. which is already sorted. type T only supports less-than < operator for comparisons. and it is a heavy function. so you have to use it as few times as possible.

Is there any better solution than a binary search? If not, is there any better solution than this, that uses less-than operator fewer times?

template<typename T>
int FindKey(const std::vector<T>& list, const T& key)
{
    if( list.empty() )
        return -1;

    int left = 0;
    int right = list.size() - 1;
    int mid;

    while( left < right )
    {
        mid = (right + left) / 2;
        if( list[mid] < key )
            left = mid + 1;
        else
            right = mid;
    }

    if( !(key < list[left]) && !(list[left] < key) )
        return left;    

    return -1;
}

It's not a real world situation, just a coding test.

Answer 1

You could trade off additional O(n) preprocessing time to get amortized O(1) query time, using a hash table (eg an unordered_map ) to create a lookup table .

Hash tables compute hash functions of the keys and do not compare the keys themselves.

Two keys could have the same hash, resulting in a collision , explaining why it's not guaranteed that every separate operation is constant time. Amortized constant time means that if you carry out k operations that took time t in total, then the quotient t/k = O(1) , for a sufficiently large k .

Live example :

#include <vector>
#include <unordered_map>

template<typename T>
class lookup {
  std::unordered_map<T, int> position;
public:
  lookup(const std::vector<T>& a) {
    for(int i = 0; i < a.size(); ++i) position.emplace(a[i], i);
  }
  int operator()(const T& key) const {
    auto pos = position.find(key);
    return pos == position.end() ? -1 : pos->second;
  }
};

This requires additional memory also.

If the values can be mapped to integers and are within a reasonable range (ie max-min = O(n) ), you could simply use a vector as a lookup table instead of unordered_map . With the benefit of guaranteed constant query time.

See also this answer to "C++ get index of element of array by value" , for a more detailed discussion, including an empirical comparison of linear, binary and hash index lookup.

Update

If the interface of type T supports no other operations than bool operator<(L, R) , then using the decision tree model you can prove a lower bound for comparison-based search algorithms to be Ω(log n).

Answer 2

You can use std::lower_bound . It does it with log(n)+1 comparisons, which is the best possible complexity for your problem.

template<typename T>
int FindKey(const std::vector<T>& list, const T& key)
{
  if(list.empty())
    return -1;
  typename std::vector<T>::const_iterator lb =
        std::lower_bound(list.begin(), list.end(), key);
  // now lb is an iterator to the first element
  // which is greater or equal to key
  if(key < *lb)
    return -1;
  else
    return std::distance(list.begin(), lb);
}

With the additionnal check for equality, you do it with log(n)+2 comparisons.

Answer 3

You can use interpolation search in log log n time if your numbers are normally distributed. If they have some other distribution, you can modify this to take your distribution into account, though I don't know which distributions yield log log time.

https://en.wikipedia.org/wiki/Interpolation_search