Tôi có thể lấy thuật toán tìm kiếm nhị phân C ++ “hữu ích” ở đâu?

Tôi cần một thuật toán tìm kiếm nhị phân tương thích với các vùng chứa C ++ STL, giống như std::binary_searchtrong tiêu <algorithm>đề của thư viện chuẩn , nhưng tôi cần nó để trả về trình lặp trỏ đến kết quả, chứ không phải một boolean đơn giản cho tôi biết liệu phần tử có tồn tại hay không.

(Một lưu ý nhỏ, ủy ban tiêu chuẩn đã nghĩ cái quái gì khi họ định nghĩa API cho binary_search ?!)

Mối quan tâm chính của tôi ở đây là tôi cần tốc độ của tìm kiếm nhị phân, vì vậy mặc dù tôi có thể tìm dữ liệu bằng các thuật toán khác, như đã đề cập bên dưới, tôi muốn tận dụng thực tế là dữ liệu của tôi được sắp xếp để có được lợi ích của một tệp nhị phân tìm kiếm, không phải là tìm kiếm tuyến tính.

cho đến nay lower_boundvà upper_boundkhông thành công nếu thiếu dữ liệu:

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

Lưu ý: Tôi cũng ổn khi sử dụng thuật toán không thuộc không gian tên std miễn là nó tương thích với vùng chứa. Như, nói boost::binary_search,.

Không có các hàm như vậy, nhưng bạn có thể viết một hàm đơn giản bằng cách sử dụng std::lower_bound, std::upper_boundhoặc std::equal_range.

Một triển khai đơn giản có thể là

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
}

Một giải pháp khác sẽ là sử dụng a std::set, đảm bảo thứ tự của các phần tử và cung cấp một phương thức iterator find(T key)trả về một trình lặp cho mục đã cho. Tuy nhiên, các yêu cầu của bạn có thể không tương thích với việc sử dụng một tập hợp (ví dụ: nếu bạn cần lưu trữ cùng một phần tử nhiều lần).

Bạn nên xem qua std::equal_range. Nó sẽ trả về một cặp trình vòng lặp cho phạm vi của tất cả các kết quả.

Có một tập hợp chúng:

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

Tìm kiếm:

• chặn dưới
• giới hạn trên
• dải_bằng
• Tìm kiếm nhị phân

Trên một ghi chú riêng:

Họ có thể nghĩ rằng việc tìm kiếm các vùng chứa có thể tạo ra nhiều hơn một kết quả. Nhưng trong những trường hợp kỳ lạ, nơi bạn chỉ cần kiểm tra sự tồn tại của một phiên bản được tối ưu hóa cũng sẽ rất hay.

Nếu std :: low_bound quá thấp so với ý muốn của bạn, bạn có thể muốn kiểm tra boost :: container :: flat_multiset . Nó là sự thay thế thả vào cho std :: multiset được triển khai dưới dạng vectơ được sắp xếp bằng cách sử dụng tìm kiếm nhị phân.

Cách triển khai ngắn nhất, tự hỏi tại sao nó không được đưa vào thư viện chuẩn:

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

Từ https://en.cppreference.com/w/cpp/algorithm/lower_bound

Kiểm tra chức năng này, qBinaryFind :

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

Thực hiện tìm kiếm nhị phân của phạm vi [bắt đầu, kết thúc) và trả về vị trí xuất hiện của giá trị. Nếu không có giá trị nào xuất hiện, trả về kết thúc.

Các mục trong phạm vi [bắt đầu, kết thúc) phải được sắp xếp theo thứ tự tăng dần; xem qSort ().

Nếu có nhiều lần xuất hiện có cùng giá trị, bất kỳ lần nào trong số chúng đều có thể được trả về. Sử dụng qLowerBound () hoặc qUpperBound () nếu bạn cần kiểm soát tốt hơn.

Thí dụ:

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)

Hàm được bao gồm trong <QtAlgorithms>tiêu đề là một phần của thư viện Qt .

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

Ví dụ: Xét một mảng, A = [1,2,3,4,5,6,7,8,9] Giả sử bạn muốn tìm kiếm chỉ mục của 3 Ban đầu, start = 0 và end = 9-1 = 8 Bây giờ , kể từ đầu <= end; giữa = 4; (array [mid] là 5)! = 3 Bây giờ, 3 nằm ở bên trái của mid vì nó nhỏ hơn 5. Do đó, chúng ta chỉ tìm kiếm phần bên trái của mảng Do đó, bây giờ start = 0 và end = 3; mid = 2.Vì mảng [mid] == 3, do đó chúng tôi nhận được số chúng tôi đang tìm kiếm. Do đó, chúng tôi trả về chỉ số của nó bằng giá trị trung bình.

Một giải pháp trả về vị trí bên trong phạm vi có thể như thế này, chỉ sử dụng các phép toán trên trình vòng lặp (nó sẽ hoạt động ngay cả khi trình lặp không số học):

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;

}