"Kullanışlı" bir C ++ ikili arama algoritmasını nereden edinebilirim?

std::binary_searchStandart kitaplığın <algorithm>başlığında olduğu gibi, C ++ STL kapsayıcılarıyla uyumlu bir ikili arama algoritmasına ihtiyacım var , ancak öğenin var olup olmadığını söyleyen basit bir boole değil, sonucu işaret eden yineleyiciyi döndürmek için ona ihtiyacım var.

(Bir yan not olarak, standart komite binary_search için API'yi tanımlarken ne düşünüyordu ?!)

Buradaki temel endişem, ikili aramanın hızına ihtiyacım olmasıdır, bu nedenle verileri diğer algoritmalarla bulabilsem de, aşağıda belirtildiği gibi, verilerimin bir ikili programın avantajlarından yararlanacak şekilde sıralanması gerçeğinden yararlanmak istiyorum. arama, doğrusal bir arama değil.

Şimdiye kadar lower_boundve upper_boundveri eksikse başarısız:

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

Not: Ayrıca, kapsayıcılarla uyumlu olduğu sürece std ad alanına ait olmayan bir algoritma kullanıyorum. Mesela, diyelim boost::binary_search.

Orada böyle bir işlev, ancak kullanarak basit bir yazabilir std::lower_bound, std::upper_boundveya std::equal_range.

Basit bir uygulama olabilir

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
}

Diğer bir çözüm std::set, öğelerin sıralanmasını garanti eden iterator find(T key)ve verilen öğeye bir yineleyici döndüren bir yöntem sağlayan a kullanmaktır . Ancak, gereksinimleriniz bir setin kullanımıyla uyumlu olmayabilir (örneğin, aynı öğeyi birden çok kez depolamanız gerekiyorsa).

Bir bakmalısın std::equal_range. Tüm sonuçların aralığına bir çift yineleyici döndürecektir.

Bir dizi var:

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

Aramak:

• alt sınır
• üst sınır
• eşit_aralık
• Ikili arama

Ayrı bir notta:

Muhtemelen kapsayıcıları aramanın birden fazla sonucu ifade edebileceğini düşünüyorlardı. Ancak, sadece varoluşu test etmeniz gereken garip durumda, optimize edilmiş bir sürüm de iyi olurdu.

Eğer std :: lower_bound beğeninize göre çok düşük seviyedeyse, boost :: container :: flat_multiset'i kontrol etmek isteyebilirsiniz . İkili arama kullanılarak sıralanmış bir vektör olarak uygulanan std :: multiset yerine açılan bir ikamedir.

En kısa uygulama, neden standart kitaplığa dahil edilmediğini merak ederek:

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

Gönderen https://en.cppreference.com/w/cpp/algorithm/lower_bound

Bu işlevi kontrol edin, qBinaryFind :

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

Aralık [başlangıç, bitiş) için ikili bir arama gerçekleştirir ve bir değer oluşumunun konumunu döndürür. Değer oluşumu yoksa, end döndürür.

[Başlangıç, bitiş) aralığındaki öğeler artan sırada sıralanmalıdır; bkz. qSort ().

Aynı değerin birçok oluşumu varsa, bunlardan herhangi biri döndürülebilir. Daha hassas kontrole ihtiyacınız varsa qLowerBound () veya qUpperBound () kullanın.

Misal:

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)

İşlev, Qt kitaplığının <QtAlgorithms>bir parçası olan başlığa dahil edilmiştir .

std :: alt_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;
}

Örnek: Bir dizi düşünün, A = [1,2,3,4,5,6,7,8,9] 3'ün dizinini aramak istediğinizi varsayalım Başlangıç ​​= 0 ve bitiş = 9-1 = 8 Şimdi başlangıç ​​<= bitiş; mid = 4; (array [mid], ki bu 5'tir)! = 3 Şimdi, 3, 5'ten küçük olduğu için ortanın solunda yer alır. Bu nedenle, dizinin yalnızca sol kısmını ararız. Dolayısıyla, şimdi start = 0 ve end = 3; mid = 2. Dizi [mid] == 3 olduğundan, aradığımız sayıyı aldık. Dolayısıyla, mid'e eşit olan endeksini döndürürüz.

Aralık içindeki konumu döndüren bir çözüm, yalnızca yineleyiciler üzerindeki işlemleri kullanarak şöyle olabilir (yineleyici aritmetik olmasa bile çalışmalıdır):

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;

}