Why is linear search so much faster than binary search? - c++

Question

Consider the following code to find a peak in an array.
#include<iostream>
#include<chrono>
#include<unistd.h>
using namespace std;
//Linear search solution
int peak(int *A, int len)
{
if(A[0] >= A[1])
return 0;
if(A[len-1] >= A[len-2])
return len-1;
for(int i=1; i < len-1; i=i+1) {
if(A[i] >= A[i-1] && A[i] >= A[i+1])
return i;
}
return -1;
}
int mean(int l, int r) {
return l-1 + (r-l)/2;
}
//Recursive binary search solution
int peak_rec(int *A, int l, int r)
{
// cout << "Called with: " << l << ", " << r << endl;
if(r == l)
return l;
if(r == l+ 1)
return (A[l] >= A[l+1])?l:l+1;
int m = mean(l, r);
if(A[m] >= A[m-1] && A[m] >= A[m+1])
return m;
if(A[m-1] >= A[m])
return peak_rec(A, l, m-1);
else
return peak_rec(A, m+1, r);
}
int main(int argc, char * argv[]) {
int size = 100000000;
int *A = new int[size];
for(int l=0; l < size; l++)
A[l] = l;
chrono::steady_clock::time_point start = chrono::steady_clock::now();
int p = -1;
for(int k=0; k <= size; k ++)
// p = peak(A, size);
p = peak_rec(A, 0, size-1);
chrono::steady_clock::time_point end = chrono::steady_clock::now();
chrono::duration<double> time_span = chrono::duration_cast<chrono::duration<double>>(end - start);
cout << "Peak finding: " << p << ", time in secs: " << time_span.count() << endl;
delete[] A;
return 0;
}
If I compile with -O3 and use the linear search solution (the peak function) it takes:
0.049 seconds
If I use the binary search solution which should be much faster (the peak_rec function), it takes:
5.27 seconds
I tried turning off optimization but this didn't change the situation. I also tried both gcc and clang.
What is going on?

Answer 1

What is going on is that you've tested it in one case of a strictly monotonically increasing function. Your linear search routine has a shortcut that checks the final two entries, so it never even does a linear search. You should test random arrays to get a true sense of the distribution of runtimes.

Answer 2

That happens because your linear search solution has an optimization for sorted arrays as the one you are passing into it. if(A[len-1] >= A[len-2]) will return your function before even approaching to enter the search loop when your array is sorted uprising so the complexity there is constant for rising sorted arrays. Your binary search however, does a full search for the array and thus takes much longer. The solution would be to fill your array randomly. You can achieve this by using a random number generator:
int main() {
std::random_device rd; /* Create a random device to seed our twisted mersenne generator */
std::mt19937 gen(rd()); /* create a generator with a random seed */
std::uniform_int_distribution<> range(0, 100000000); /* specify a range for the random values (choose whatever you want)*/
int size = 100000000;
int *A = new int[size];
for(int l=0; l < size; l++)
A[l] = range(gen); /* fill the array with random values in the range of 0 - 100000000
[ . . . ]
EDIT:
One very important thing when you fill your array randomly: your function will not work with unsorted arrays since if the first element is grater than the second or the last one is greater than the previous, the function returns even if there was a value inbetween which is much greater. So remove those lines if you expect unsorted arrays (which you should since a search a peak element is always constant complexity for sorted arrays and there is no point in searching one)