Question

% java BinarySearch 1.txt < 2.txt

If I have two text files (1.txt and 2.txt), where 2.txt contains values not in 1.txt, how does the binary search work in giving us these values? If the arguments to BinarySearch are a key and a sorted array, I don’t see how this applies.

Here is the code for the binary search:

import java.util.Arrays;

public class BinarySearch {

    // precondition: array a[] is sorted
    public static int rank(int key, int[] a) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo <= hi) {
            // Key is in a[lo..hi] or not present.
            int mid = lo + (hi - lo) / 2;
            if      (key < a[mid]) hi = mid - 1;
            else if (key > a[mid]) lo = mid + 1;
            else return mid;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] whitelist = In.readInts(args[0]);

        Arrays.sort(whitelist);

        // read key; print if not in whitelist
        while (!StdIn.isEmpty()) {
            int key = StdIn.readInt();
            if (rank(key, whitelist) == -1)
                StdOut.println(key);
        }
    }
}

According to Wikipedia, and from what I’d understood: A binary search or half-interval search algorithm finds the position of a specified value (the input “key”) within a sorted array.

So how is it working to find uncommon values in two text files?

Answer 1

As I understand the question, you want to know how this program works when it (correctly) determines an entry in 2.txt is NOT in 1.txt. That has a pretty simple answer.

This algorithm sorts the array whitelist. It initializes the lo pointer to point to element 0 and the hi pointer to point to element whitelist.length-1 which is the last elment in whitelist. The array segment is the whole array for the first iteration. The array must be ordered or sorted for this to work.

For each successive iteration, if the value is not found in the middle of the current array segment, the logic determines whether the value has to be in the half-segment above the middle or the half-segment below the middle. That half-segment, excluding the old middle element, becomes the new search segment for the next iteration. The algorithm adjusts the hi and lo pointers to close in, one half of the remaining segment of the array at a time, on where the searched for value has to be, if it is in the array.

Eventually, for a search value not in the array, hi and lo (and therefore mid) will converge to the same single element and it will be the last segment of the array searched, a segment of just one element. If that element doesn’t have the search value, then, depending on the search value and that element’s value either hi will become mid – 1 or lo will become mid + 1. Either way, the while continuation condition will become false because lo <= hi is no longer true. The new remaining search segment now has a negative size. This can be interpreted as meaning that if a return doesn’t occur before the while terminates, then the search didn’t find the value in any previous segment and there is no remaining segment to search. Therefore, the search value can’t be in the array.

The implementation given in this question works. I’ve tested it usng the Princeton.edu stdlib that contains the In and StdIn classes used here. I’ve compiled and run it from a command line using stdin pipe to pipe in the second text file. I don’t think I would implement this application like this except as a demonstration of binary search methods, perhaps for a class or examining some techniques.

Here is some further background on why a binary search is used. The reason to use a binary search is to obtain a worst case 2*logBase2(n) execution complexity with an average 1.5*logBase2(n) complexity. A binary search for a value not in the array will always be the worst case of 2*logBase2(n) compares.

A binary search is vastly superior to a linear search that just starts at one end of the array and searches every elemnt until it finds a match or comes to the end of the array. The average search may be about n/2, depending on the distribution of values in the array. A linear search for a value not in the array will always have the worst case of n compares.

In a binary search, each pair of compares eliminates half the possibilites. An array of 1024 entries can be searched in a maximum of 20 compares. Compare that to a 1024 maximum for a linear search. Squaring the size of the searched array only doubles the number of compares for a binary search. A binary search can search an array with 1,048,576 entries with a maximum of 40 compares. Compare that to a linear search maximum of 1,048,576.

The basic binary search algorithm given in the question can be very useful with objects that inherit from a sorted or ordered collection and where you have to implement your own compare and search method to overload the inherited methods. As long as you have a compare that determines less, greater and equal amongst objects, and the collection is ordered or sorted according to that compare, you can use this basic binary search algorithm to search the collection.