template<class T>
int BinarySearch(T a[], const T& x, int n)
{      // Search a[0] <= a[1] <= ... <= a[n-1] for x
       // Return position if found; return ­1 otherwise
    int left = 0, right = n-1;
         
    while (left <= right)
    {
       int middle = (left+right)/2;
       if (x==a[middle]) return middle ;
       if (x>a[middle]) left=middle+1;
       else right=middle-1;
    }
    return ­1; //x not found  
}


Let R be the number of locations left to probe in the binary
search algorithm.  Let N be the size of the original list.  R
will be no more than N/2 after the first pass through the
loop.  Noting that a second pass through the loop is just like
a first pass with a list of size no more than N/2, we can
conclude also that R will be no more than N/4 after a second
pass, and no more than N/(2^k) after k passes.

If N=1 then since R is no more than N/2 after one pass, and
since R has to be an integer, then the search requires no more
than one pass in the case N = 1.

In the case N = 2 or 3, N/4 < 1, so the search does not take
more than 2 passes in the case N = 2 or 3.

In the case N = 4, 5, 6, or 7, N/8 < 1, so the search does not
take more than 3 passes.

In the case N = 8, 9, 10, 11, 12, 13, 14, or 15, N/16 < 1, so
the search does not take more than 4 passes.

In general, if N= 2^k, (2^k)+1, (2^k)+2, ..., or (2^k)+(2^k)-1
(the last term equals 2^(k+1) - 1), then since N/(2^(k+1)) < 1,
the search does not take more than k+1 passes.  

Another way of saying this is that when 2^k <= N <= 2^(k+1)-1,
the search takes at most k+1 passes.  For these values of N,
k=floor(log(N)), and k+1 = floor(log(N)) + 1.  

Thus we may conclude that binary search requires no more than
floor(log(N)) + 1 passes through the loop.

work(N) <= floor(log(N)) + 1 <= log(N) + 1 < 2*log(N) (when N > 1)

Therefore work(N) is O(log(N)).

What is the ratio of these upper limits if we make N twice as
large?  

(log(2N) + 1)/(log(N) + 1) = (log(2N) + 1)/log(2N) = 1 +
(1/log(2N)).

So you see work increasing by only a small factor (much less
than twice the work to process twice the data.)  In fact, the
result is very impressive, in that the multiplier (1 +
(1/log(2N))) converges to 1 as N-->infinity.  In other words,
when N is large, if we magnify the size of N by 2, the
associated work is magnified hardly at all!