An addition to Jon Skeets post: The potential faster implementation is actually not hard to implement and adds only 2 lines of code, here is how I’d do it: if (midVal < key) low = mid + 1; else if (midVal > key) high = mid – 1; else if (low != mid) //Equal but … Read more
Here’s my favorite implementation of binary search. It’s useful not only for finding the element but also for finding the insertion index. Details about assumed sorting order (ascending or descending) and behavior with respect to equal elements are controlled by providing a corresponding predicate (e.g. { $0 < x } vs { $0 > x … Read more
You will get the result in O(lg n) public static void PrintIndicesForValue(int[] numbers, int target) { if (numbers == null) return; int low = 0, high = numbers.length – 1; // get the start index of target number int startIndex = -1; while (low <= high) { int mid = (high – low) / 2 … Read more
In short, (high + low) >>> 1 is a trick that uses the unused sign-bit to perform a correct average of non-negative numbers. Under the assumption that high and low are both non-negative, we know for sure that the upper-most bit (the sign-bit) is zero. So both high and low are in fact 31-bit integers. … Read more
Because the collection is sorted, you can do a modified binary search in O( log n ) : public static int search(int value, int[] a) { if(value < a[0]) { return a[0]; } if(value > a[a.length-1]) { return a[a.length-1]; } int lo = 0; int hi = a.length – 1; while (lo <= hi) { … Read more
The book: Data Structures and Algorithm Analysis in Java (2nd Edition), by Mark Allen Weiss Says that a D&C algorithm should have two disjoint recursive calls, just like QuickSort does. Binary Search does not have this, even though it can be implemented recursively.
Well, as the list is sorted, all the entries you are interested in are contiguous. This means you need to find the first item equal to the found item, looking backwards from the index which was produced by the binary search. And the same about last item. You can simply go backwards from the found … Read more
I am a big fan of Java’s MappedByteBuffers for situations like this. It is blazing fast. Below is a snippet I put together for you that maps a buffer to the file, seeks to the middle, and then searches backwards to a newline character. This should be enough to get you going? I have similar … Read more
If the array elements are not guaranteed to be distinct, then it’s not possible to do this in O(log n) time. The reason for this is the following: suppose that you have an array where all n > 1 values are the same. In this case, none of the elements can be local minima, because … Read more
Here are the equivalent implementations of upper_bound and lower_bound. This algorithm is O(log(n)) in the worst case, unlike the accepted answer which gets to O(n) in the worst case. Note that here high index is set to n instead of n – 1. These functions can return an index which is one beyond the bounds … Read more