std::binary_search

From cppreference.com
 
 
 
Defined in header <algorithm>
template< class ForwardIterator, class T >

bool binary_search( ForwardIterator first, ForwardIterator last,

                    const T& value );
(1)
template< class ForwardIterator, class T, class Compare >

bool binary_search( ForwardIterator first, ForwardIterator last,

                    const T& value, Compare comp );
(2)

Checks if the sorted range [first, last) contains an element equal to value. The first version uses operator< to compare the elements, the second version uses the given comparison function comp.

Contents

[edit] Parameters

first, last - the range of elements to examine
value - value to compare the elements to
comp - comparison function which returns ​true if the first argument is less than the second.

The signature of the comparison function should be equivalent to the following:

bool cmp(const Type1 &a, const Type2 &b);

The signature does not need to have const &, but the function must not modify the objects passed to it.
The type  Type1 must be such that an object of type T can be implicitly converted to  Type1. The type  Type2 must be such that an object of type ForwardIterator can be dereferenced and then implicitly converted to  Type2. ​

[edit] Return value

true if an element equal to value is found, false otherwise.

[edit] Complexity

logarithmic in the distance between first and last

[edit] Possible implementation

[edit] Example

#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    std::vector<int> haystack {1, 3, 4, 5, 9};
    std::vector<int> needles {1, 2, 3};
 
    for (auto needle : needles) {
        std::cout << "Searching for " << needle << '\n';
        if (std::binary_search(haystack.begin(), haystack.end(), needle)) {
            std::cout << "Found " << needle << '\n';
        } else {
            std::cout << "no dice!\n";
        }
    }
}

Output:

Searching for 1
Found 1
Searching for 2
no dice!
Searching for 3
Found 3

[edit] See also

returns range of elements matching a specific key
(function template)