Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

binary_search

Comprueba si hay un elemento en un intervalo ordenado que sea igual a un valor especificado o equivalente a este del modo especificado por un predicado binario.

template<class ForwardIterator, class Type>
   bool binary_search(
      ForwardIterator first, 
      ForwardIterator last,
      const Type& value
   );
template<class ForwardIterator, class Type, class BinaryPredicate>
   bool binary_search(
      ForwardIterator first, 
      ForwardIterator last,
      const Type& value, 
      BinaryPredicate comp
   );

first

Un iterador de avance que direcciona la posición del primer elemento del intervalo en el que se va a buscar.

last

Un iterador de avance que direcciona la posición uno pasado el primer elemento del intervalo en el que se va a buscar.

value

El valor necesario para que coincida con el valor del elemento o que debe satisfacer la condición con el valor del elemento especificado por el predicado binario.

comp

Objeto de función de predicado definido por el usuario que define el sentido en el que un elemento es menor que otro. Un predicado binario acepta dos argumentos y devuelve truecuando se cumple y false cuando no se cumple.

true si un elemento se encuentra en el intervalo que es igual o equivalente al valor especificado; de lo contrario, false.

El intervalo de origen ordenado al que se hace referencia debe ser válido; todos los punteros deben ser desreferenciables y, dentro de la secuencia, la última posición debe ser accesible desde la primera por incrementación.

Cada valor del intervalo ordenado debe estar organizado como una condición previa a la aplicación del algoritmo binary_search de acuerdo con la misma ordenación que va a usar el algoritmo que va a ordenar los intervalos combinados.

Los intervalos de origen no son modificados por binary_search.

Los tipos de valores de los iteradores de avance tienen que ser comparables en el sentido de menos que para ordenarse, de manera que, si hay dos elementos, se puede determinar que son equivalentes (en el sentido de que ninguno es menos que el otro) o que uno es menor que el otro. Esto produce una ordenación entre los elementos desiguales

La complejidad del algoritmo es logarítmica para los iteradores de acceso aleatorio y lineal en cualquier otro caso con el número de pasos proporcionales a (lastfirst).

// alg_bin_srch.cpp
// compile with: /EHsc
#include <list>
#include <vector>
#include <algorithm>
#include <functional>      // greater<int>( )
#include <iostream>

// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser( int elem1, int elem2 )
{
    if (elem1 < 0)
        elem1 = - elem1;
    if (elem2 < 0)
        elem2 = - elem2;
    return elem1 < elem2;
}

int main( )
{
    using namespace std;

    list <int> List1;

    List1.push_back( 50 );
    List1.push_back( 10 );
    List1.push_back( 30 );
    List1.push_back( 20 );
    List1.push_back( 25 );
    List1.push_back( 5 );

    List1.sort();

    cout << "List1 = ( " ;
    for ( auto Iter : List1 )
        cout << Iter << " ";
    cout << ")" << endl;

    // default binary search for 10
    if( binary_search(List1.begin(), List1.end(), 10) )
        cout << "There is an element in list List1 with a value equal to 10."
        << endl;
    else
        cout << "There is no element in list List1 with a value equal to 10."
        << endl;

    // a binary_search under the binary predicate greater
    List1.sort(greater<int>());
    if( binary_search(List1.begin(), List1.end(), 10, greater<int>()) )
        cout << "There is an element in list List1 with a value greater than 10 "
        << "under greater than." << endl;
    else
        cout << "No element in list List1 with a value greater than 10 "
        << "under greater than." << endl;

    // a binary_search under the user-defined binary predicate mod_lesser
    vector<int> v1;

    for( auto i = -2; i <= 4; ++i )
    {
        v1.push_back(i);
    }

    sort(v1.begin(), v1.end(), mod_lesser);

    cout << "Ordered using mod_lesser, vector v1 = ( " ;
    for( auto Iter : v1 )
        cout << Iter << " ";
    cout << ")" << endl;

    if( binary_search(v1.begin(), v1.end(), -3, mod_lesser) )
        cout << "There is an element with a value equivalent to -3 "
        << "under mod_lesser." << endl;
    else
        cout << "There is not an element with a value equivalent to -3 "
        << "under mod_lesser." << endl;
}

List1 = ( 5 10 20 25 30 50 )
There is an element in list List1 with a value equal to 10.
There is an element in list List1 with a value greater than 10 under greater than.
Ordered using mod_lesser, vector v1 = ( 0 -1 1 -2 2 3 4 )
There is an element with a value equivalent to -3 under mod_lesser.

Encabezado: <algorithm>

Espacio de nombres: std

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft