Namespaces
Variants

std:: bsearch

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
bsearch
Numeric operations
Operations on uninitialized memory
Definido en el encabezado <cstdlib>
void * bsearch ( const void * key, const void * ptr, std:: size_t count,

std:: size_t size, /* c-compare-pred */ * comp ) ;
void * bsearch ( const void * key, const void * ptr, std:: size_t count,

std:: size_t size, /* compare-pred */ * comp ) ;
(1)
extern "C" using /* c-compare-pred */ = int ( const void * , const void * ) ;
extern "C++" using /* compare-pred */ = int ( const void * , const void * ) ;
(2) ( solo para exposición* )

Encuentra un elemento igual al elemento apuntado por key en un array apuntado por ptr . El array contiene count elementos de size bytes cada uno y debe estar particionado con respecto al objeto apuntado por key , es decir, todos los elementos que se comparan como menores deben aparecer antes de todos los elementos que se comparan como iguales, y estos deben aparecer antes de todos los elementos que se comparan como mayores que el objeto clave. Un array completamente ordenado cumple con estos requisitos. Los elementos se comparan usando la función apuntada por comp .

El comportamiento no está definido si el array no está ya particionado en orden ascendente con respecto a la clave, de acuerdo con el mismo criterio que comp utiliza.

Si el array contiene varios elementos que comp indicaría como iguales al elemento buscado, entonces no está especificado cuál elemento devolverá la función como resultado.

Contenidos

Parámetros

key - puntero al elemento a buscar
ptr - puntero al array a examinar
count - número de elementos en el array
size - tamaño de cada elemento del array en bytes
comp - función de comparación que retorna un valor entero negativo si el primer argumento es menor que el segundo, un valor entero positivo si el primer argumento es mayor que el segundo y cero si los argumentos son equivalentes. key se pasa como primer argumento, un elemento del array como segundo.

La firma de la función de comparación debe ser equivalente a la siguiente:

int cmp ( const void * a, const void * b ) ;

La función no debe modificar los objetos pasados a ella y debe retornar resultados consistentes cuando se llama para los mismos objetos, independientemente de sus posiciones en el array.

Valor de retorno

Puntero al elemento encontrado o puntero nulo si el elemento no se ha encontrado.

Notas

A pesar del nombre, ni los estándares de C ni POSIX requieren que esta función se implemente mediante búsqueda binaria ni ofrecen garantías de complejidad.

Las dos sobrecargas proporcionadas por la biblioteca estándar de C++ son distintas porque los tipos del parámetro comp son distintos (el enlace de lenguaje es parte de su tipo).

Ejemplo

#include <array>
#include <cstdlib>
#include <iostream>
template<typename T>
int compare(const void *a, const void *b)
{
    const auto &arg1 = *(static_cast<const T*>(a));
    const auto &arg2 = *(static_cast<const T*>(b));
    const auto cmp = arg1 <=> arg2;
    return cmp < 0 ? -1
        :  cmp > 0 ? +1
        :  0;
}
int main()
{
    std::array arr{1, 2, 3, 4, 5, 6, 7, 8};
    for (const int key : {4, 8, 9})
    {
        const int* p = static_cast<int*>(
            std::bsearch(&key,
                arr.data(),
                arr.size(),
                sizeof(decltype(arr)::value_type),
                compare<int>));
        std::cout << "value " << key;
        if (p)
            std::cout << " found at position " << (p - arr.data()) << '\n';
        else
            std::cout << " not found\n";
    }
}

Salida:

value 4 found at position 3
value 8 found at position 7
value 9 not found

Véase también

ordena un rango de elementos con tipo no especificado
(función)
devuelve el rango de elementos que coinciden con una clave específica
(plantilla de función)
Documentación C para bsearch