Searching Arbitrary Arrays

[comp1110-87]
  • Fabian Muehlboeck

Binary Search is very efficient, but depends on the array being sorted. This may not be true of any array you might encounter. So, as a first attempt, you might want to use the sortedness checker from Example [comp1110-1K] to see if the array is sorted, and then depending on that either use binary search or the linear search procedure we saw in Example [comp1110-16].

boolean search(int[] haystack, int needle) { if(isSorted(haystack)) { return binarySearch(haystack, needle); } else { return linearSearch(haystack, needle); } }

The problem with the above approach is that when we are checking whether the array is sorted, we have to go through every element of the array. At that point, we might just check whether those elements are equal to needle right away.

The general idea is more reasonable if there are several things that we want to search for. In that case, we only have to go through the array once, and if it happens to be sorted, we can then use binarySearch many times, efficiently finding each element.

But better yet, in that case, we might just want to sort the array to guarantee that we can do those later searches efficiently.

Context

    Back to Search

    [comp1110-86]
    • Fabian Muehlboeck

    Example. CLI driver for search procedures

    [comp1110-1M]
    • Liam O'Connor

    To make manual testing easier, we'll make a suitable main function that reads a certain number of inputs one number at a time using IO.readln() and then calls our search function.

    void main() { int length = 10; int[] a1 = new int[length]; int i = 0; while(i < length) { a1[i] = Integer.parseInt(IO.readln()); i = i + 1; } assert(binarySearch(a1, 5)); assert(binarySearch(a1, 1)); assert(binarySearch(a1, 10)); assert(binarySearch(a1, 9)); assert(!binarySearch(a1, 0)); assert(!binarySearch(a1, 15)); }

    The flexibility is nice, by but running this and manually entering a bunch of numbers every time can be a bit of a slog. You can therefore create a file, say "numbers.txt" (the file extension does not really matter), that contains those numbers:

    1 2 3 4 5 6 7 8 9 10

    You can of course create several different files with different lists of numbers.

    To use those files, you can call your program in a special way. If you normally start the program by writing:

    java BinarySearch

    You can instead write:

    java BinarySearch < numbers.txt

    The combination of a less-than sign < with a filename after it tells your terminal emulator to read that file and use it as the standard input for the program, instead of prompting the user. We use the same idea in Homework 1.

    Example. Sortedness Checker

    [comp1110-1K]
    • Liam O'Connor, Fabian Muehlboeck
     boolean isSorted(int[] haystack) { int i = 0; while(i < haystack.length - 1) { if(haystack[i] > haystack[i + 1]) { return false; } } return true; }

    Searching Arbitrary Arrays

    [comp1110-87]
    • Fabian Muehlboeck

    Binary Search is very efficient, but depends on the array being sorted. This may not be true of any array you might encounter. So, as a first attempt, you might want to use the sortedness checker from Example [comp1110-1K] to see if the array is sorted, and then depending on that either use binary search or the linear search procedure we saw in Example [comp1110-16].

    boolean search(int[] haystack, int needle) { if(isSorted(haystack)) { return binarySearch(haystack, needle); } else { return linearSearch(haystack, needle); } }

    The problem with the above approach is that when we are checking whether the array is sorted, we have to go through every element of the array. At that point, we might just check whether those elements are equal to needle right away.

    The general idea is more reasonable if there are several things that we want to search for. In that case, we only have to go through the array once, and if it happens to be sorted, we can then use binarySearch many times, efficiently finding each element.

    But better yet, in that case, we might just want to sort the array to guarantee that we can do those later searches efficiently.

    Related

      Binary Search

      [comp1110-77]
      • Fabian Muehlboeck

      Example. Guessing Game

      [comp1110-13]
      • Liam O'Connor, Fabian Muehlboeck

      In the lecture, we created a guessing game, choosing a "random" number based on a fair die roll.

      int generateNumber() { return 34; } void main() { int secret = generateNumber(); boolean correctGuess = false; while(!correctGuess) { String guess = IO.readln("Guess a number! "); int guessedNumber = Integer.parseInt(guess); if(guessedNumber == secret) { IO.println("You win!"); correctGuess = true; } else if(secret < guessedNumber) { IO.println("Smaller!"); } else { IO.println("Bigger!"); } } }

      Note. Bounding our Guesses

      [comp1110-14]
      • Liam O'Connor, Fabian Muehlboeck

      If we know that the range of possible answers in Example [comp1110-13] is \(0\) to \(100\), then we can algorithmically devise a procedure that will always guess the right answer:

      1. We know that the number is between \(0\) and \(100\). Guess \(50\). We get the report Smaller!.
      2. We know that the number is between \(0\) and \(49\). Guess \(25\). We get the report Bigger!.
      3. We know that the number is between \(26\) and \(49\). Guess \(37\). We get the report Smaller!.
      4. We know that the number is between \(26\) and \(36\). Guess \(31\). We get the report Bigger!.
      5. We know that the number is between \(32\) and \(36\). Guess \(34\). We succeed.

      Following this procedure of always bisecting the possible range means that we will always get the answer in at most \(\log _2 100 \simeq 7\) guesses. In general, this bisecting means that for a range \(0\) to \(n\), we will get the answer in at most \(\log _2 n\) guesses.

      Example. Binary Search

      [comp1110-1J]
      • Liam O'Connor

      If we add a precondition to the spec of contains, that the input array is sorted, we can use a trick similar to our solution algorithm for our guessing game, which as we saw, can reduce the amount of iterations of the program from linear in the size of the input to logarithmic.

      The idea is that we consistently pick the middle index from the range of possible indices. If the value at this index is our target, we have found what we're looking for, and we're done. If the value at this index is larger than our target, that means our desired index is to the left, and reduces the range of possible indices by half. If it is smaller, then our desired index is to the other half, on the right of the selected midpoint.

      This narrows the range of possible indices, which permits us to repeat this technique until we reach single elements.

      /** Searches for a needle in a sorted haystack @param haystack a sorted (in ascending order) array of integers @param needle an integer to be searched for @return true iff there exists i, haystack[i] == needle */ boolean binarySearch(int[] haystack, int needle) { int lower = 0; int upper = haystack.length - 1; while(lower <= upper) { // INV: if there exists i, haystack[i] == needle, // then lower <= i <= upper int middle = (lower + upper) / 2; if(needle == haystack[middle]) { return true; } else if(needle > haystack[middle]) { lower = middle + 1; } else { upper = middle - 1; } } return false; }

      Example. Searching for an Element in an Array, Generally

      [comp1110-16]
      • Liam O'Connor, Fabian Muehlboeck
       boolean contains(int[] haystack, int needle) { int i = 0; while(i < haystack.length) { // i <= haystack.length && forall 0 <= j < i, haystack[j] != needle if(needle == haystack[i]) { return true; } i = i + 1; } // i == haystack.length // forall 0 <= j < haystack.length, haystack[j] != needle return false; }

      Example. Sortedness Checker

      [comp1110-1K]
      • Liam O'Connor, Fabian Muehlboeck
       boolean isSorted(int[] haystack) { int i = 0; while(i < haystack.length - 1) { if(haystack[i] > haystack[i + 1]) { return false; } } return true; }
      bars magnifying-glass caret-down plus minus arrow-right xmark