1. Chapter 8 Search and Sort
©Rick Mercer

2. Binary Search
Binary search serves the same service as sequential search, but faster
Especially when there are many array elements
You employ a similar algorithm when you look up a name in a phonebook
while the element is not found and it still may be in the array {
if the element in the middle of the array is the matches
store the reference and signal that the element was found
else
eliminate correct half of the array from further search }

3. Binary Search
We'll see that binary search can be a more efficient algorithm for searching.
It works only on sorted arrays like this
Compare the element in the middle
if that's the target, quit and report success
if the key is smaller, search the array to the left
otherwise search the array to the right
This process repeats until we find the target or there is nothing left to search

4. Some preconditions For Binary Search to work The array must be sorted
The indexes referencing the first and last elements must represent the entire range of meaningful elements in the array

5. Binary search a small array
Here is the array that will be searched
int n = 9;
String[] a = new String[n];
// Insert elements in natural order (according to
// the compareTo method of the String class
a[0] = "Bob";
a[1] = "Carl";
a[2] = "Debbie";
a[3] = "Evan";
a[4] = "Froggie";
a[5] = "Gene";
a[6] = "Harry";
a[7] = "Igor";
a[8] = "Jose";
// The array is filled to capacity in this example

6. Initialize other variables
Several assignments to get things going
int first = 0;
int last = n - 1;
String searchString = "Harry";
// –1 means the element has not yet been found
int indexInArray = -1;
The first element to be compared is the one in the middle.
int mid = ( first + last ) / 2;
If the middle element matches searchString, stop
Otherwise move low above mid or high below mid
This will eliminate half of the elements from the search
The next slide shows the binary search algorithm

7. Binary Search Algorithm
while indexInArray is -1 and there are more elements {
if searchString is equal to name[mid] then
let indexInArray = mid // array element equaled searchString
else if searchString alphabetically precedes name[mid]
eliminate mid last elements from the search
else
eliminate first mid elements from the search
mid = ( first + last ) / 2; // Compute a new mid for the next iteration }
Next slide shows mid goes from 4 to (5+8)/2=6

8. Binary Search Harry Data reference pass 1 pass 2 Bob a[0] a[1] a[2]
first
mid
last
first
mid found
last
Carl
Debbie
Evan
Froggie
Gene
Harry
Igor
Jose

9. Binary Search Alice not in array
pass5 ?
data reference pass pass pass 3
last
first mid
Bob
a[0]
a[1]
a[2]
a[3]
a[4]
a[5]
a[6]
a[7]
a[8]
first
mid
last
first
mid
last
first
mid last
Carl
Debbie
Evan
Froggie
At pass4 (not shown) all integers are 0 to consider the first in the array. However at pass5, last becomes -1. At pass5, indexInArray is still -1, however last is < first to indicate the element was not found. The loop test:
while(indexInArray == -1 && first <= last)
Gene
Harry
Igor
Jose

10. Binary Search Code
while(indexInArray == -1 && (first <= last)) { if( searchString.equals(a[mid] ) ) indexInArray = mid; // found else if( searchString.compareTo(a[mid] ) < 0 ) last = mid-1 ; // may be in 1st half else first= mid+1; // may be in second mid = ( first + last ) / 2; } System.out.println("Index of " + searchString + ": " + indexInArray);

11. How fast is Binary Search?
Best case: 1
Worst case: when target is not in the array
At each pass, the "live" portion of the array is narrowed to half the previous size.
The series proceeds like this:
n , n/2, n/4, n/8, ...
Each term in the series is 1 comparison
How long does it take to get to 1?
This will be the number of comparisons

12. Graph Illustrating Relative growth logarithmic and linear
f(n)
searching with sequential search
searching with binary search n

13. Comparing sequential search to binary search
Rates of growth and logarithmic functions

14. Other logarithm examples
The guessing game:
Guess a number from 1 to 100
try the middle, you could be right
if it is too high
check near middle of 1..49
if it is too low
check near middle of
Should find the answer in a maximum of 7 tries
If , a maximum of 2c >= 250, c == 8
If , a maximum of 2c >= 500, c == 9
If , a maximum of 2c >= 1000, c == 10

15. Logarithmic Explosion
Assuming an infinitely large piece of paper that can be cut in half, layered, and cut in half again as often as you wish.
How many times do you need to cut and layer until paper thickness reaches the moon?
Assumptions
paper is inches thick
distance to moon is 240,000 miles
240,000 * 5,280 feet per mile * 12 inches per foot = 152,060,000,000 inches to the moon

16. Examples of Logarithmic Explosion
The number of bits required to store a binary number is logarithmic add 1 bit to get much larger ints
8 bits stored 256 values log2256 = 8
log 2,147,483,648 = 31
The inventor of chess asked the Emperor to be paid like this:
1 grain of rice on the first square, 2 on the next, double grains on each successive square 263

17. Compare Sequential and Binary Search
Output from CompareSearches.java (1995)
Search for objects
Binary Search
#Comparisons:
Average: 13
Run time: 20ms
Sequential Search
#Comparisons:
Average: 10000
Run time: 9930ms
Difference in comparisons :
Difference in milliseconds: 9910

18. Sorting an Array

19. Sorting
The process of arranging array elements into ascending or descending order
Ascending (where x is an array object):
x[0] <= x[1] <= x[2] <= ... <= x[n-2] <= x[n-1]
Descending:
x[0] >= x[1] >= x[2] >= ... >= x[n-2] >= x[n-1]
Here's the data used in the next few slides:

20. Swap smallest with the first
// Swap the smallest element with the first top = 0 smallestIndex = top for i ranging from top+1 through n – 1 { if test[ i ] < test[ smallestIndex ] then smallestIndex = i } // Question: What is smallestIndex now __________? swap test[ smallestIndex ] with test[ top ]

21. Selection sort algorithm
Now we can sort the entire array by changing top from 0 to n-2 with this loop
for (top = 0; top < n-1; top++)
for each subarray, move the smallest to the top
The top moves down one array position each time the smallest is placed on top
Eventually, the array is sorted

22. Selection sort runtimes Actual observed data on a slow pc
in thousands