Wo kann ich einen "nützlichen" binären C ++ - Suchalgorithmus bekommen?

Ich benötige einen binären Suchalgorithmus, der mit den C ++ STL-Containern kompatibel ist, ähnlich wie std::binary_searchim <algorithm>Header der Standardbibliothek , aber ich brauche ihn, um den Iterator zurückzugeben, der auf das Ergebnis zeigt, und keinen einfachen Booleschen Wert, der mir sagt, ob das Element vorhanden ist.

(Nebenbei bemerkt, was zum Teufel hat das Standardkomitee gedacht, als es die API für binary_search definiert hat?!)

Mein Hauptanliegen hierbei ist, dass ich die Geschwindigkeit einer binären Suche benötige. Obwohl ich die Daten mit anderen Algorithmen finden kann, wie unten erwähnt, möchte ich die Tatsache nutzen, dass meine Daten sortiert sind, um die Vorteile einer binären Suche zu nutzen Suche, keine lineare Suche.

bisher lower_boundund upper_boundscheitern, wenn das Datum fehlt:

//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

Hinweis: Ich kann auch einen Algorithmus verwenden, der nicht zum Standard-Namespace gehört, solange er mit Containern kompatibel ist. Wie zum Beispiel boost::binary_search.

Es gibt keine solche Funktionen, aber Sie können eine einfache Verwendung schreiben std::lower_bound, std::upper_boundoder std::equal_range.

Eine einfache Implementierung könnte sein

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
}

Eine andere Lösung wäre die Verwendung von a std::set, die die Reihenfolge der Elemente garantiert und eine Methode bereitstellt iterator find(T key), die einen Iterator für das angegebene Element zurückgibt. Ihre Anforderungen sind jedoch möglicherweise nicht mit der Verwendung eines Satzes kompatibel (z. B. wenn Sie dasselbe Element mehrmals speichern müssen).

Sie sollten einen Blick darauf werfen std::equal_range. Es werden zwei Iteratoren in den Bereich aller Ergebnisse zurückgesetzt.

Es gibt eine Reihe von ihnen:

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

Suchen nach:

• lower_bound
• obere Grenze
• gleicher Bereich
• binäre Suche

Auf einem separaten Hinweis:

Sie dachten wahrscheinlich, dass die Suche nach Containern mehr als ein Ergebnis ergeben könnte. Aber gelegentlich, wenn Sie nur auf Existenz testen müssen, wäre auch eine optimierte Version schön.

Wenn std :: lower_bound für Ihren Geschmack zu niedrig ist, sollten Sie boost :: container :: flat_multiset überprüfen . Es ist ein Drop-In-Ersatz für std :: multiset, das mithilfe der binären Suche als sortierter Vektor implementiert wird.

Die kürzeste Implementierung, die sich fragt, warum sie nicht in der Standardbibliothek enthalten ist:

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;
}

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

Überprüfen Sie diese Funktion, qBinaryFind :

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

Führt eine binäre Suche des Bereichs [Anfang, Ende] durch und gibt die Position eines Wertvorkommens zurück. Wenn kein Wert vorkommt, wird end zurückgegeben.

Die Elemente im Bereich [Anfang, Ende] müssen in aufsteigender Reihenfolge sortiert werden. siehe qSort ().

Wenn es viele Vorkommen mit demselben Wert gibt, kann eines davon zurückgegeben werden. Verwenden Sie qLowerBound () oder qUpperBound (), wenn Sie eine genauere Steuerung benötigen.

Beispiel:

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)

Die Funktion ist im <QtAlgorithms>Header enthalten, der Teil der Qt- Bibliothek ist.

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;
}

Beispiel: Betrachten Sie ein Array, A = [1,2,3,4,5,6,7,8,9] Angenommen, Sie möchten den Index 3 durchsuchen. Beginnen Sie zunächst mit 0 = 0 und beenden Sie jetzt mit 9-1 = 8 , da start <= end; Mitte = 4; (Array [Mitte], das 5 ist)! = 3 Nun liegt 3 links von Mitte, da es kleiner als 5 ist. Daher suchen wir nur den linken Teil des Arrays. Daher ist jetzt Start = 0 und Ende = 3; mid = 2.Since array [mid] == 3, daher haben wir die Nummer erhalten, nach der wir gesucht haben. Daher geben wir seinen Index zurück, der gleich mid ist.

Eine Lösung, die die Position innerhalb des Bereichs zurückgibt, könnte wie folgt aussehen und nur Operationen für Iteratoren verwenden (dies sollte auch dann funktionieren, wenn der Iterator nicht rechnet):

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;

}