ฉันจะหาอัลกอริธึมการค้นหาไบนารี C ++ ที่“ มีประโยชน์” ได้จากที่ใด

ฉันต้องการอัลกอริทึมการค้นหาแบบไบนารีที่เข้ากันได้กับคอนเทนเนอร์ C ++ STL บางอย่างเช่นstd::binary_searchใน<algorithm>ส่วนหัวของไลบรารีมาตรฐานแต่ฉันต้องการให้มันส่งคืนตัววนซ้ำที่ชี้ไปที่ผลลัพธ์ไม่ใช่บูลีนธรรมดาที่บอกฉันว่ามีองค์ประกอบอยู่หรือไม่

(โปรดทราบว่าคณะกรรมการมาตรฐานคิดอะไรอยู่เมื่อพวกเขากำหนด API สำหรับ binary_search!)

ข้อกังวลหลักของฉันที่นี่คือฉันต้องการความเร็วของการค้นหาแบบไบนารีดังนั้นแม้ว่าฉันจะสามารถค้นหาข้อมูลด้วยอัลกอริทึมอื่น ๆ ดังที่ได้กล่าวไว้ด้านล่าง แต่ฉันต้องการใช้ประโยชน์จากข้อเท็จจริงที่ว่าข้อมูลของฉันถูกจัดเรียงเพื่อให้ได้ประโยชน์จากไบนารี ค้นหาไม่ใช่การค้นหาเชิงเส้น

จนถึงตอนนี้lower_boundและupper_boundล้มเหลวหากไม่มีข้อมูล:

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

หมายเหตุ:ฉันยังใช้อัลกอริทึมที่ไม่ได้เป็นของเนมสเปซมาตรฐานตราบใดที่เข้ากันได้กับคอนเทนเนอร์ ชอบพูดboost::binary_search.

ไม่มีฟังก์ชั่นดังกล่าว แต่คุณสามารถเขียนง่ายๆโดยใช้std::lower_bound, หรือstd::upper_boundstd::equal_range

การใช้งานง่ายๆอาจเป็นได้

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
}

อีกวิธีหนึ่งคือการใช้ a std::setซึ่งรับประกันการเรียงลำดับขององค์ประกอบและให้วิธีการiterator find(T key)ที่ส่งคืนตัววนซ้ำไปยังรายการที่กำหนด อย่างไรก็ตามข้อกำหนดของคุณอาจใช้ไม่ได้กับการใช้ชุด (ตัวอย่างเช่นหากคุณต้องการจัดเก็บองค์ประกอบเดียวกันหลายครั้ง)

คุณควรดูที่std::equal_range. มันจะส่งคืนคู่ของตัวทำซ้ำไปยังช่วงของผลลัพธ์ทั้งหมด

มีชุดของพวกเขา:

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

ค้นหา:

• lower_bound
• upper_bound
• ช่วงที่เท่ากัน
• binary_search

ในหมายเหตุแยกต่างหาก:

พวกเขาอาจคิดว่าการค้นหาคอนเทนเนอร์สามารถเรียกผลลัพธ์ได้มากกว่าหนึ่งรายการ แต่ในโอกาสแปลก ๆ ที่คุณต้องทดสอบการมีอยู่ของเวอร์ชันที่ปรับให้เหมาะสมก็จะดีเช่นกัน

หากมาตรฐาน :: lower_bound เกินไปในระดับต่ำสำหรับความชอบของคุณคุณอาจต้องการตรวจสอบเพิ่ม :: ภาชนะ :: flat_multiset เป็นการแทนที่แบบดรอปอินสำหรับ std :: multiset ที่ใช้เป็นเวกเตอร์ที่เรียงลำดับโดยใช้การค้นหาแบบไบนารี

การใช้งานที่สั้นที่สุดสงสัยว่าทำไมจึงไม่รวมอยู่ในไลบรารีมาตรฐาน:

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

จากhttps://en.cppreference.com/w/cpp/algorithm/lower_bound

ตรวจสอบฟังก์ชันนี้qBinaryFind :

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

ทำการค้นหาแบบไบนารีของช่วง [เริ่มต้นสิ้นสุด) และส่งกลับตำแหน่งของค่าที่เกิดขึ้น หากไม่มีค่าเกิดขึ้นให้คืนค่าสิ้นสุด

รายการในช่วง [เริ่มต้นสิ้นสุด) ต้องเรียงลำดับจากน้อยไปมาก ดู qSort ()

หากมีการเกิดขึ้นหลายครั้งที่มีค่าเดียวกันอาจส่งคืนรายการใดรายการหนึ่ง ใช้ qLowerBound () หรือ qUpperBound () หากคุณต้องการการควบคุมที่ละเอียดกว่านี้

ตัวอย่าง:

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)

ฟังก์ชันนี้รวมอยู่ใน<QtAlgorithms>ส่วนหัวซึ่งเป็นส่วนหนึ่งของไลบรารี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;
}

ตัวอย่าง: พิจารณาอาร์เรย์ A = [1,2,3,4,5,6,7,8,9] สมมติว่าคุณต้องการค้นหาดัชนีของ 3 ในขั้นต้น start = 0 และ end = 9-1 = 8 ตอนนี้ ตั้งแต่เริ่ม <= end; กลาง = 4; (array [mid] ซึ่งเป็น 5)! = 3 ตอนนี้ 3 อยู่ทางซ้ายของ mid เนื่องจากมีขนาดเล็กกว่า 5 ดังนั้นเราจึงค้นหาเฉพาะส่วนด้านซ้ายของอาร์เรย์ดังนั้นตอนนี้ start = 0 และ end = 3; mid = 2 เนื่องจาก array [mid] == 3 ดังนั้นเราจึงได้หมายเลขที่เรากำลังค้นหา ดังนั้นเราจึงคืนค่าดัชนีซึ่งเท่ากับค่ากลาง

วิธีแก้ปัญหาที่ส่งคืนตำแหน่งภายในช่วงอาจเป็นเช่นนี้โดยใช้การดำเนินการกับตัววนซ้ำเท่านั้น (ควรใช้งานได้แม้ว่าตัววนซ้ำจะไม่ใช่เลขคณิต)

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;

}