Dove posso trovare un algoritmo di ricerca binaria C ++ "utile"?

Ho bisogno di un algoritmo di ricerca binaria che sia compatibile con i contenitori C ++ STL, qualcosa come std::binary_searchnell'intestazione della libreria standard <algorithm>, ma mi serve per restituire l'iteratore che punta al risultato, non un semplice booleano che mi dice se l'elemento esiste.

(In una nota a margine, cosa diavolo stava pensando il comitato standard quando ha definito l'API per binary_search ?!)

La mia preoccupazione principale qui è che ho bisogno della velocità di una ricerca binaria, quindi anche se posso trovare i dati con altri algoritmi, come indicato di seguito, voglio sfruttare il fatto che i miei dati sono ordinati per ottenere i vantaggi di un binario ricerca, non una ricerca lineare.

finora lower_bounde upper_boundfallire se manca il dato:

//lousy pseudo code
vector(1,2,3,4,6,7,8,9,0) //notice no 5
iter = lower_bound_or_upper_bound(start,end,5)
iter != 5 && iter !=end //not returning end as usual, instead it'll return 4 or 6

Nota: sto anche bene usando un algoritmo che non appartiene allo spazio dei nomi std purché sia ​​compatibile con i contenitori. Come, ad esempio, boost::binary_search.

Non esistono funzioni di questo tipo, ma puoi scriverne una semplice usando std::lower_bound, std::upper_boundo std::equal_range.

Potrebbe essere una semplice implementazione

template<class Iter, class T>
Iter binary_find(Iter begin, Iter end, T val)
{
    // Finds the lower bound in at most log(last - first) + 1 comparisons
    Iter i = std::lower_bound(begin, end, val);

    if (i != end && !(val < *i))
        return i; // found
    else
        return end; // not found
}

Un'altra soluzione sarebbe usare a std::set, che garantisce l'ordinamento degli elementi e fornisce un metodo iterator find(T key)che restituisce un iteratore all'elemento dato. Tuttavia, le tue esigenze potrebbero non essere compatibili con l'uso di un set (ad esempio se devi memorizzare lo stesso elemento più volte).

Dovresti dare un'occhiata std::equal_range. Restituirà una coppia di iteratori alla gamma di tutti i risultati.

Ce n'è una serie:

http://www.sgi.com/tech/stl/table_of_contents.html

Cercare:

• limite inferiore
• limite superiore
• equal_range
• binary_search

In una nota separata:

Probabilmente stavano pensando che la ricerca di contenitori potesse indicare più di un risultato. Ma nelle strane occasioni in cui hai solo bisogno di testare l'esistenza di una versione ottimizzata sarebbe anche carina.

Se std :: lower_bound è di livello troppo basso per i tuoi gusti, potresti voler controllare boost :: container :: flat_multiset . È un sostituto immediato per std :: multiset implementato come vettore ordinato utilizzando la ricerca binaria.

L'implementazione più breve, chiedendosi perché non è inclusa nella libreria standard:

template<class ForwardIt, class T, class Compare=std::less<>>
ForwardIt binary_find(ForwardIt first, ForwardIt last, const T& value, Compare comp={})
{
    // Note: BOTH type T and the type after ForwardIt is dereferenced 
    // must be implicitly convertible to BOTH Type1 and Type2, used in Compare. 
    // This is stricter than lower_bound requirement (see above)

    first = std::lower_bound(first, last, value, comp);
    return first != last && !comp(value, *first) ? first : last;
}

Da https://en.cppreference.com/w/cpp/algorithm/lower_bound

Controlla questa funzione, qBinaryFind :

RandomAccessIterator qBinaryFind ( RandomAccessIterator begin, RandomAccessIterator end, const T & value )

Esegue una ricerca binaria dell'intervallo [inizio, fine) e restituisce la posizione di un'occorrenza di valore. Se non sono presenti occorrenze di valore, restituisce end.

Gli elementi nell'intervallo [inizio, fine) devono essere ordinati in ordine crescente; vedere qSort ().

Se sono presenti molte occorrenze dello stesso valore, è possibile restituirne una qualsiasi. Usa qLowerBound () o qUpperBound () se hai bisogno di un controllo più preciso.

Esempio:

QVector<int> vect;
 vect << 3 << 3 << 6 << 6 << 6 << 8;

 QVector<int>::iterator i =
         qBinaryFind(vect.begin(), vect.end(), 6);
 // i == vect.begin() + 2 (or 3 or 4)

La funzione è inclusa <QtAlgorithms>nell'intestazione che fa parte della libreria Qt .

std :: lower_bound () :)

int BinarySearch(vector<int> array,int var)
{ 
    //array should be sorted in ascending order in this case  
    int start=0;
    int end=array.size()-1;
    while(start<=end){
        int mid=(start+end)/2;
        if(array[mid]==var){
            return mid;
        }
        else if(var<array[mid]){
            end=mid-1;
        }
        else{
            start=mid+1;
        }
    }
    return 0;
}

Esempio: Considera un array, A = [1,2,3,4,5,6,7,8,9] Supponi di voler cercare l'indice di 3 Inizialmente, inizio = 0 e fine = 9-1 = 8 Ora , da inizio <= fine; mid = 4; (array [mid] che è 5)! = 3 Ora, 3 si trova a sinistra di mid in quanto è minore di 5. Pertanto, cerchiamo solo la parte sinistra dell'array Quindi, ora start = 0 e end = 3; mid = 2. Poiché array [mid] == 3, abbiamo ottenuto il numero che stavamo cercando. Quindi, restituiamo il suo indice che è uguale a metà.

Una soluzione che restituisce la posizione all'interno dell'intervallo potrebbe essere questa, utilizzando solo operazioni sugli iteratori (dovrebbe funzionare anche se l'iteratore non fa aritmetica):

template <class InputIterator, typename T>
size_t BinarySearchPos(InputIterator first, InputIterator last, const T& val)
{       
    const InputIterator beginIt = first;
    InputIterator element = first;
    size_t p = 0;
    size_t shift = 0;
    while((first <= last)) 
    {
        p = std::distance(beginIt, first);
        size_t u = std::distance(beginIt, last);
        size_t m = p + (u-p)/2;  // overflow safe (p+u)/2
        std::advance(element, m - shift);
        shift = m;
        if(*element == val) 
            return m; // value found at position  m
        if(val > *element)
            first = element++;
        else
            last  = element--;

    }
    // if you are here the value is not present in the list, 
    // however if there are the value should be at position u
    // (here p==u)
    return p;

}