递归二进制搜索“超出范围”

Question

just wondering if someone could help me out with my attempt at writing a recursive binary search. It is currently throwing up a 'out of range' error:

terminate called after throwing an instance of 'std::out_of_range'
what():  vector::_M_range_check: __n (which is 0) >= this->size() (which is 0)
Aborted (core dumped)

I'm sure it's to do with my failed attempt at writing correct recursion (which I am still new at). If anyone could give me a hint as to where the issue lies I would be greatly appreciative. Here is my code:

RecursiveBinarySearch.cpp

    // RecursiveBinarySearch class constructor.
RecursiveBinarySearch::RecursiveBinarySearch()
{

}

// Sets the object that is being searched for. 
// In this case, we are always looking for the integer '1'.
int obj = 1;

// Searching the vector given for obj. if obj is found the function returns true, otherwise it returns false.
bool RecursiveBinarySearch::binarySearch(std::vector<int> vec, int mid)
{
    int start = 0, end = vec.size() - 1;
    std::cout << "mid : " << mid << "\n";

    while (start + 1 < end)
    {

        if (vec.at(mid) == obj)
            return true;

        else if (vec.at(mid) > obj)
            //end = mid - 1;
            return binarySearch(vec, mid - 1);

        else
            //start = mid + 1;
            return binarySearch(vec, mid + 1);

    }

    if ((vec.at(start) == obj) || (vec.at(end) == obj))
        return true;
    else
    {
        return false;
    }
}

// RecursiveBinarySearch class destructor.
RecursiveBinarySearch::~RecursiveBinarySearch()
{

}

main.cpp:

int main()
{

    // The user inputs a string of numbers (e.g. "6 4 -2 88 ..etc") and those integers are then put into a vector named 'vec'.
    std::vector<int> vec;
    int vecSize = vec.size();
    int mid = (vec.at(0) + vec.at(vecSize - 1)) / 2;

    std::string line;
    if (getline(std::cin, line))
    {
        std::istringstream str(line);

        int value;
        str >> value;
        vec.push_back(value);
        while (str >> value)
        {
            vec.push_back(value);
        }
    }

    // Creating RecursiveBinarySearch object.
    RecursiveBinarySearch bSearch;
    RecursiveBinarySearch *ptrBSearch = &bSearch;
    bool bS = ptrBSearch->binarySearch(vec, mid);

    // Print out inputted integers.
    std::cout << "Binary Search Result: \n";
    std::cout << bS << "\n";

    return 0;
}

Thanks!

Answer 1

Out-of-range simply means you're indexing beyond your range limits (either low or high) for your given sequence container. And props to you for using at() to catch the issue.

Your posted code has several issues. Among them, the most devastating is improper midpoint calculation. You're finding value averages; not mid point, then using those as indexes, which is clearly wrong. Your initial mid value is also wrong, as it is taken prior to any elements being in your container.

An important point also, you should be using a const reference to your container. Otherwise, you making copies of the entire container with each recursive call. It may not seem such a big deal, but do this with a hundred-million items and I assure you it will be a very expensive.

That said, your setup is simply wrong . Recursive binary search is about divide-and-conquer (I expect you know that). As a requirement for logarithmic search, the sequence must be sorted . Beyond that, the most straight-forward approach to accomplish this with a sequence container requires you know three things:

• The value you seek (duh)
• The index (or iterator) of the item you're starting with.
• The one-past index (or end-iterator) denoting the end-of-sequence position of the current partition.

That last one always throws people new to the algorithm for a loop, but it makes sense when you begin doing the math. In short, think of it as the first index where you're not searching, not an inclusive index where you are searching. It also makes coding the algorithm, either iteratively or recursively, straightforward.

Only when you have all of the above can you produce a recursive algorithm with an escape condition , which is critical. You must have a way to stop doing what you're doing.

Using your parameter list and providing the missing pieces, a recursive version looks like this:

bool binarySearchR(std::vector<int> const& v, size_t beg, size_t end, int val)
{
    // when these are equal it means there are no elements
    //  left to search, and that means no match was found.
    if (beg == end)
        return false;

    // find midpoint
    size_t mid = beg + (end-beg)/2;

    // if the test value is less, recurse to upper partition
    //  important: we just checked 'mid', so the lower point
    //  is one *past* that; therefore ++mid is the recursed
    //  'beg' index.
    if (v[mid] < val)
        return binarySearchR(v, ++mid, end, val);

    // if the test value is greater, recurse to lower partition
    //  important: we don't check the 'end' index, it's the
    //  stopping point so just pass it as the recursed 'end' index;
    //  'mid' is therefore not modified here.
    if (val < v[mid])
        return binarySearchR(v, beg, mid, val);

    // not lesser, not greater, thus equal
    return true;
}

You can further simplify this by overloading the function to simply take a vector by const-reference and a value, then invoke the recursive function:

bool binarySearchR(std::vector<int> const& v, int val)
{
    return binarySearchR(v, 0, v.size(), val);
}

This allows you to invoke it like this:

int main()
{
    std::vector<int> vec { 1,2,3,4,6,9,10 };
    std::cout << std::boolalpha;

    for (int i=-1; i<=11; ++i)
        std::cout << std::setw(2) << i << ':' << binarySearchR(vec, i) << '\n';
}

Output

-1:false
 0:false
 1:true
 2:true
 3:true
 4:true
 5:false
 6:true
 7:false
 8:false
 9:true
10:true
11:false

The output is as-expected, and test values and edge cases work correctly.

---

Iterator-based Recursive Binary Search

An iterator-based approach is much more inline with how modern C++ works, and as a bonus extends the operation to other sequence containers such as std::deque . It follows the same overall design as described above, but uses a template-based Iter type:

template<class Iter>
bool binarySearchR(Iter beg, Iter end, typename std::iterator_traits<Iter>::value_type const& arg)
{
    if (beg == end)
        return false;

    Iter mid = std::next(beg, std::distance(beg,end)/2);
    if (*mid < arg)
        return binarySearchR(++mid, end, arg);

    if (arg < *mid)
        return binarySearchR(beg, mid, arg);

    return true;
}

We could likewise overload this to take just a vector (which we assume is sorted) and a test value, but why stop there. We can craft a template that takes a template-type as one of the arguments, and thanks to C++11 and variadic template arguments, it brings an elegant solution:

template<class T, template<class, class...> class C, class... Args>
bool binarySearchR(C<T,Args...> const& seq, T const& val)
{
    return binarySearchR(std::begin(seq), std::end(seq), val);
}

The same test program from the prior section will then work, and produce the same results.

---

Binary Search Without Recursion

Once you get the hang of the algorithm, you quickly discover it lends itself well to an iterative algorithm instead of recursive. It honestly won't matter much in terms of call-stack space. A binary search of 2.4 billion sorted items will only recurse at-most 31 times, but still, that's unnecessary calls and it would be nice if we can avoid them. Further it may optimize better, and that's always something worth considering:

template<class Iter>
bool binarySearchI(Iter beg, Iter end, typename std::iterator_traits<Iter>::value_type const& arg)
{
    while (beg != end)
    {
        Iter mid = std::next(beg, std::distance(beg,end)/2);
        if (*mid < arg)
            beg = ++mid;
        else if (arg < *mid)
            end = mid;
        else return true;
    }
    return false;
}

The same overload applies:

template<class T, template<class, class...> class C, class... Args>
bool binarySearchI(C<T,Args...> const& seq, T const& val)
{
    return binarySearchI(std::begin(seq), std::end(seq), val);
}

And it produces the same results we are expecting.

Answer 2

Lets take a closer look at

    std::vector<int> vec;
    int vecSize = vec.size();
    int mid = (vec.at(0) + vec.at(vecSize - 1)) / 2;

Breaking it down, we get

    std::vector<int> vec;

Creates an empty vector

    int vecSize = vec.size();

The size of an empty vector will be zero, so

    int mid = (vec.at(0) + vec.at(vecSize - 1)) / 2;

always resolves to

    int mid = (vec.at(0) + vec.at(0 - 1)) / 2;

and vec.at(0 - 1) is not a good place for vectors to go.

Solution: Compute mid later AFTER loading the vector.

As an afterthought, consider providing binarySearch with the item to search for as a parameter. The current implementation is not re-entrant.

Answer 3

Taking a closer look at your algorithm. Few things to note:

1. your binary search takes in 2 params vector and mid, binarySearch(std::vector vec, int mid) For any recursive algorithm to work you need to have 2 things, a stopping condition (so you don't end up in infinite loops) and a recursive condition ( which with each recursion takes you closer to your solution, in case of binary search it would be something that reduces your search space by half ) In you case your vector passed in is always the same, and the start and end calculated are also the same everything, resulting in the same search space everytime. You need to either pass in a new start and end recursively or you need to modify your vector in each recursive pass.

2. You define you mid as follows: int mid = (vec.at(0) + vec.at(vecSize - 1)) / 2; by doing this you are defining your mid to be the average of the first and last elements of the vector and not their positions. For eg. vector = [ 2, 5, 60, 75, 80], your mid would be (2+80)/2 = 41, and 41 is definitely not a valid position in your vector. your mid should instead be (0 + 4) / 2 which is = 2; you can get this by using your start and end and should be recalculated each time inside your recursive function.