recursive binary search condition - recursion

Question

I have a question about the condition of "entering" the "if condition" in the below recursive binary search:
http://www.fredosaurus.com/notes-cpp/algorithms/searching/rbinarysearch.html
int rBinarySearch(int sortedArray[], int first, int last, int key) {
// function:
// Searches sortedArray[first]..sortedArray[last] for key.
// returns: index of the matching element if it finds key,
// otherwise -(index where it could be inserted)-1.
// parameters:
// sortedArray in array of sorted (ascending) values.
// first, last in lower and upper subscript bounds
// key in value to search for.
// returns:
// index of key, or -insertion_position -1
// if key is not in the array.
if (first <= last) {
int mid = (first + last) / 2; // compute mid point.
if (key == sortedArray[mid])
return mid; // found it.
else if (key < sortedArray[mid])
// Call ourself for the lower part of the array
return rBinarySearch(sortedArray, first, mid-1, key);
else
// Call ourself for the upper part of the array
return rBinarySearch(sortedArray, mid+1, last, key);
}
return -(first + 1); // failed to find key
}
Specifically, I have a question regarding the part if (first <= last).
I was trying to hand trace the step of the above recursion function. For example, I write down an array of say [2, 5, 7, 11, 21, 26, 27, 36, 37, 42] and let the key be 1, i.e. key = 1.
Then I have in the first recursion, I think my first = 0, and last = 9.
So mid = (0 + 9)/2 = 4.5 (but mid will be 4 since mid is assigned to be int).
So mid[4] > 1, so then I have the next recursion being (arr[], 0, 4-1=3, 1),..... and so on.....
However it seems that the case of last < first doesn't seem to appear. I am just wondering is it actually possible for the case of last < first to happen? (i.e.. is the condition if (first <=last) necessary?)
If it is necessary, could someone illustrate with a very simple example that I can hand trace with to understand that this condition is necessary?
thanks

Answer 1

That condition is the stopping criterion for the case if the element that you are looking for is not an element of the array that you are searching.
In your example, if you further exercise it, the recursive calls will be
// first, last
rBinarySearch(arr[], 0, 3, 1); // -> mid = 1 -> else if
rBinarySearch(arr[], 0, 0, 1); // -> mid = 0 -> else if
rBinarySearch(arr[], 0, -1, 1); // there you go: last < first (i.e. -1 < 0)