Chapter 14 Searching and Sorting Section 1 - Sequential or Linear Search Section 2 - Binary Search Section 3 - Selection Sort Section 4 - Insertion Sort

Chapter 14

Searching and Sorting

Section 1 - Sequential or Linear Search

Section 2 - Binary Search

Section 3 - Selection Sort

Section 4 - Insertion Sort

Section 5 - Merge Sort

1

Go

Go

Go

Go

Go

Searches and SortsThere are two search algorithms and three sort algorithms that

you need to know for the AP Exam:

• Sequential Search also called Linear Search• Binary Search

• Selection Sort• Insertion Sort• Merge Sort

We will discuss each and note some important facts about each one.

2

Chapter 14 - Section 1

Sequential or Linear Search

3

Sequential Search or Linear Search

Sequential Search also called Linear Search can be performed

on a sorted or unsorted array.

As the name indicates, the search process begins at the start of

the list (usually a standard array) and checks the first element

to see if it is the target value. If it is not, the process continues

with each element being checked until the value is found or

the end of the list is reached.

When it is found, the position of the target value (it’s index) is

returned by the method.

If the target value is NOT found, then the value -1 is returned.

4

Sequential Search of an Array of intsOnly one loop is necessary for Sequential Search. The code is

usually contained in a method and a target value being searched for is passed to it.

public static int sequentialSearchInts (int [ ] arr, int searchValue)

{

for (int i = 0; i < arr.length; i++)

{

if (arr [ i ] == searchValue)

{

return i; // if found return the index of the target value

}

}

return -1; // if target value NOT found return -1

} 5

Sequential Search of an Array of intsThe variable checks can be added to see how many checks are needed to find

the target value.

public static int sequentialSearchInts (int [ ] arr, int target){

checks = 0;for (int i = 0; i < arr.length; i++){

checks++; // increment as a value is checkedif (arr [ i ] == target){

System.out.println(”Found the value after " + checks + " checks!");

return i; }

}System.out.println("The value was NOT found by Linear Search!");return -1;

}6

Sequential Search of a 2D Array of intsA two-dimensional array can be searched also, but two loops are necessary.

public static int TwoDArraySearchInts (int [ ] [ ] arr, int target){ for (int row = 0; row < arr.length; row ++) {

for (int col = 0; col < arr[row].length; col++) {

if (arr [ row ][col] == target) {

return i; // if found return the index of the target value }

} } return -1; // if target value NOT found return -1 }

7

Sequential Search of an Array of StringsThe code is almost the same for a list of objects, except the equals method is

used for the type of object. Here the array contains String values:

public static int sequentialSearchStrings (String [ ] arr, String target)

{


{

if ( arr [ i ]. equals (target) )

{


}

}


}

8

Sequential Search of an Array of StudentsThe code is almost the same for a list of objects, except the equals method is

used for the type of object. Here the array contains String values:

public static int linearSearchStudents (Student [ ] arr, Student target)

{


{

if ( arr [ i ]. equals (target) )

{


}

}


}

Notice the code is not any different from the code for searching strings because the Student class has an equals method. 9

Sequential Search of an ArrayList of StudentsThe code is almost the same for an ArrayList of Student objects. We only

need to replace [ ] with a call to the get method:

public static int search (ArrayList <Student> arr, Student target)

{for (int i = 0; i < arr.size(); i++){

if ( arr.get(i). equals (target) ){ return i; // if found return the index of the target

value }

} return -1; // if target value NOT found return -1 }

Notice the code is almost the same as searching a standard array of Student objects.

10


Binary Search

11

Binary SearchBinary Search must be performed on a sorted array. If you try to use it

on an unsorted list, you will get erroneous results. You may be told

a value was not found when it was actually in the list.

Binary Search is a divide and conquer algorithm. The search process

begins at the middle of the list. The midpoint is calculated by using

the index values of the first array location and the last array location.

The code has two variables left and right that refer to those index

values. If the value at the midpoint index is the target value, then

the search is over and the index value of the midpoint is returned.

If the target value is not stored at the midpoint index, then the process

continues using a comparison of the target value and the value at

the midpoint to see which half of the array will be excluded from the

remainder of the search process. 12

Binary Search Codepublic static int binarySearchInts (int [] arr, int target){ checks = 0; int left = 0; int right = arr.length - 1; while (left <= right) { checks++; int midpoint = (left + right) / 2; if (arr[midpoint] == target) { System.out.println(”Found after " + checks + " checks!"); return midpoint; } else if (arr[midpoint] < target) left = midpoint + 1; else right = midpoint - 1; }

System.out.println("The value was NOT found by Binary Search!");return -1; // if target not found return -1

}13

Binary Search

The Binary Search algorithm uses the following code:

midpoint = (left + right) / 2;

It is extremely important that you are aware that midpoint, left,

and right are int variables, because if the array has 8

elements, then when the search starts, the value of left is 0

and the value of right is 7.

(0 + 7) / 2 is equal to 3 NOT 3.5 because this is integer division

which truncates the remainder.

So the first midpoint value would be the index 3.

If the target value is found, then the variables left and right get

new values and a new midpoint is checked. 14

Binary SearchBecause the Binary Search algorithm successively divides the

array in half during each check for the target value, its name is representative of what is happening.

Mathematically, we can express the number of checks Binary Search takes to find a target value as log2n. That is “the log

base 2 of n”.

So how many checks need to be done to find a target value in an array of size 8?

log28 which is equal to log2(23) which is equal to 3.

Actually because of the integer division truncation of the statement midpoint = (left + right) / 2; it takes one more (4) when there are eight if the target value is in the last index 7.

So we will summarize this for you on the next slide:15

Binary Search’s Efficiency is log2n + 1

If Binary Search looks for a target value in an array of size 7, it takes at most 3 checks to see if the target value is in the list. The numbers in red indicate the 1st, 2nd, or 3rd checks that would be made in finding any of the values in the array or one not in it.

[0] [1] [2] [3] [4] [5] [6]

5 10 15 20 25 30 35

3 2 3 1 3 2 3

However, notice the numbers when there are 8 values in the list:

[0] [1] [2] [3] [4] [5] [6] [7]

5 10 15 20 25 30 35 40

3 2 3 1 3 2 3 4 16

The Number of Checks for Binary SearchSo here is the rule on how to find the number of checks it takes to find

a target value in an array:

You take the log base 2 of the next highest power of 2.

value of n

0 – 7 elements takes … log2(8) or log2(23) = 3 checks



32 - 63 elements takes … log2(64) or log2(26) = 6 checks

64 - 127 elements takes … log2(128) or log2(27) = 7 checks

This can be summarized in general as: log2n + 1

So you can see when n is 8 it takes 4 checks: log28 + 1 = 3 + 1 = 4 17

Recursive Binary Search

18

Recursive Binary Search Code

public int binarySearch (int[] arr, int target){

int pos = recurBinarySearch (arr, target, 0, arr.length - 1);return pos;

}

private int recurBinarySearch (int[] arr, int target, int left, int right){ if (left > right)

return -1; else

{

int midpoint = (left + right) / 2;

if (arr[midpoint] == target)

return midpoint;

else if (arr[midpoint] < target)

return recurBinarySearch (arr, target, midpoint + 1, right);

else

return recurBinarySearch (arr, target, left, midpoint - 1); }} 19

Efficiency of the SearchesThe efficiency of Sequential Search is pretty good for small sized

arrays up to size 1000. Computer processors are fast enough that it would not matter if you are performing a Sequential Search or a Binary Search.

However, if the array is much larger, above size 1000, then Binary Search will always be faster than Sequential Search.

Here is a table that shows the Best, Worst, and Average case efficiencies of Sequential and Binary Search.

Mathematically log2n is better than n. Graphing y = log n and y = n shows

you why. As n increases log n doesn’t increase as fast as n.

Search

of n elements

Best Case Worst Case Average Case

Sequential 1 check n checks n / 2 checks

Binary 1 check log2n checks log2n checks

20


Selection Sort

21

Selection SortSelection Sort gets its name from the fact that during the first “pass”, the

smallest element in the array is “selected” and swapped to the first

position in the array. It does this by keeping track of the index where

the current smallest element is located using the variable minIndex. As

it makes a pass it continually checks all values in order to see if they

are smaller than the current smallest element.

On the second pass, the next to the smallest element is swapped into the

second position in the array and so on until the largest element is

placed in the last position in the array.

Using this approach, the elements end up in “ascending order” in the array

(smallest to largest).

The algorithm can also be written to place the largest element in the first

position in the array, the next to the largest element in the second

position and so on until the elements are in reverse or “descending

order”. (largest to smallest ). 22

Selection Sort

The main efficiency of Selection Sort is that there is only one swap per

pass. In computer time, swaps take longer to process than just

checking something. So a lot of swaps can be bad for efficiency.

The code can also be written to swap the largest element to the last

location of the array, the next to the largest element into the next to

the last location in the array and so on. In this case the elements

will be in ascending order. Its just that we are manipulating the

largest item during each pass instead of the smallest.

The code can also be written to swap the smalles element to the last

location of the array, the next to the smallest element into the next to

the last location in the array and so on. In this case the elements

will be in descending order. Its just that we are manipulating the

smallest item during each pass instead of the smallest. 23

Selection SortLet’s say that an array has the following values stored in it with the element 18 stored in

index 0:

18 13 6 23 8

Selection Sort finds that the smallest element is in index 2, so it swaps 6 with the first

element 18 stored in index 0.

6 13 18 23 8 First pass over! 6 is out of the sorting process.

Selection Sort finds that the next smallest element is in index 4, so it swaps 8 with the first

element in the part of the array still being sorted, 13.

6 8 18 23 13 Second pass over! 8 is out of the sorting process.



6 8 13 23 18 Third pass over! 13 is out of the sorting process.



6 8 13 18 23 Fourth pass over! 18 is out of the sorting process.

On the last pass 23 is already in order so no swap is made. 24

Selection Sort Ascending Order for intspublic static void selectionSortInts(int [ ] arr){ swaps = 0; int minIndex; for (int i = 0; i < arr.length - 1; i++) {

minIndex = i;

for (int index = i + 1; index < arr.length; index++)if (arr[index] < arr[minIndex])

minIndex = index;

int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex]= temp;swaps++;

}System.out.println("It took " + swaps + " swaps using Selection Sort!");} 25

Selection Sort Descending Order for intspublic static void selectionSortInts(int [ ] arr){ swaps = 0; int maxIndex; for (int i = 0; i < arr.length - 1; i++) {

maxIndex = i;

for (int index = i + 1; index < arr.length; index++)if (arr[index] > arr[maxIndex])

maxIndex= index;

int temp = arr[i];arr[i] = arr[maxIndex];arr[maxIndex]= temp;swaps++;


Using compareTo for Sorting

To be able to sort String values, we need to use the compareTo

method of the String class. If we need to sort values of another kind of

object, then we need to make sure there is a compareTo method of

that class.

Let’s review the information on the compareTo method of the String

class originally given you in the Chapter 7 PowerPoint on Strings.

27

Sect 6 - int compareTo (String other)

Consider the code:

String s1 = reader.nextLine(); String s2 = reader.nextLine();

In the call of the method compareTo below, s1 is this and s2 is

other …..

if (s1.compareTo(s2) == 0) and the compareTo method

returns one of the following values when it is made:

• a negative integer if this is lexicographically less than other

• 0 if this is equal to other

• a positive integer if this is lexicographically greater than other

One thing the compareTo() method is valuable for is to help us

sort String values in a list. We will eventually do this. 28


The following code compares the string values in word1 and word2 to

identify the lexicographical order of word1 and word2.

String word1 = reader.nextLine();

String word2 = reader.nextLine();

if (word1.compareTo (word2) < 0)

System.out.println(word1 + “ comes before ” + word2);

else if (word1.compareTo (word2) > 0)

System.out.println(word1 + “ comes after ” + word2);

else if (word1.compareTo (word2) == 0)

System.out.println(word1 + “ is equal to ” + word2); 29

lexicographical indicates alphabetical order


If word1 comes before word2, then a negative int value is returned by

word1.compareTo (word2 ). If word1 comes after word2, then a

positive int value is returned. If word1 exactly equals word2, then zero

is returned.

if (word1.compareTo (word2 ) < 0)


else if (word1.compareTo (word2 ) > 0)


else if (word1.compareTo (word2 ) == 0)

System.out.println(word1 + “ is equal to ” + word2);30

Sect 6 - int compareTo (String other)In this code, word1 is the receiver object this and word2 is other.

String word1 = “a”;

String word2 = “b”;






System.out.println(word1 + “ is equal to ” + word2);

Output: “a comes before b”

Note: “a”.compareTo(“b”) returns -1 based on the Unicode (ASCII)

values for “a” and “b” … 97 - 98 = -1 31

Note that word1 is calling the method.



String word2 = “c”;







Output: “a comes before b”

Note: “a”.compareTo(“c”) returns -2 based on the Unicode values for

“a” and “c” … 97 - 99 = -2 32


String word1 = “apple”;

String word2 = “banana”;







Output: “apple comes before banana”

Note: “apple”.compareTo(“banana”) returns -1 based on the Unicode

values for “a” and “b” … 97 - 98 = -1. Only the first two characters

are compared, because they are different. 33


String word1 = “b”;








Output: “b comes after a”

Note: “b”.compareTo(“a”) returns +1 based on the Unicode values for

“b” and “a” … 98 - 97 = 1 34


String word1 = “d”;








Output: “b comes after a”

Note: “d”.compareTo(“a”) returns +3 based on the Unicode values for

“d” and “a” … 100 - 97 = 3 35


String word1 = “bear”;

String word2 = “bearcats”;







Output: “banana comes after apple”

Note: “bear”.compareTo(“bearcats”) returns -4 based on the fact that

the words are the same but the second one has 4 additional

characters. “bearcats”.compareTo(“bear”) returns +4. 36


String word1 = “bearclaw”;









Note: “bearclaw”.compareTo(“bearcats”) returns +11 based on the

Unicode values for “l” and “a” … 108 - 97 = 11. Only the first two

characters that are different are compared. 37



String word2 = “bearclaw”;








Note: “bearclaw”.compareTo(“bearcats”) returns -11 based on the

Unicode values for “a” and “l” … 97 - 108 = -11. Only the first two

characters that are different are compared. 38

Writing a Student Class compareTo Method

You will also write a compareTo Method in the Student class. It can be

used to sort a list of Student objects. A class like Student or Person

can only properly include a compareTo method if it implements the

Comparable interface using templating in the class definition line:

public class Person implements Comparable <Person>

Let’s look at what a compareTo method of the Person class would look

like on the next slide.

39

CompareTo Method for the Person classpublic int compareTo(Person other) // note the parameter is Person not Object{ if (! (other instanceof Person )) throw new IllegalArgumentException("Parameter must be a Person.");

if( this.name.compareTo(other.name) == 0) { if ( this.address.equals(other.address) ) return 0; else if ( this.address.compareTo(other.address) < 0 ) return -1; else // if ( this.address.compareTo(other.address) > 0) return 1; } else if ( this.name.compareTo(other.name) < 0 ) return -1; else // if ( this.name.compareTo(other.name) > 0 ) return 1;} 40

The Selection Sort Code for Stringspublic static void selectionSortStrings(String [ ] arr){ swaps = 0; int minIndex; for (int i = 0; i < arr.length - 1; i++) {

minIndex = i;

for (int index = i + 1; index < arr.length; index++)if (arr[index].compareTo(arr[minIndex]) < 0)

minIndex = index;



The Selection Sort Code for Studentspublic static void selectionSortStudents(Student [ ] arr){ swaps = 0; int minIndex; for (int i = 0; i < arr.length - 1; i++) {

minIndex = i;

for (int index = i + 1; index < arr.length; index++)if (arr[index].compareTo(arr[minIndex]) < 0)

minIndex = index;



Selection SortNote that all versions of the algorithm have a nested loop structure. If

there are n elements in the array, the outer loop runs approximately

n times and the inner for loop runs approximately n times.

This fact causes this algorithm to have an efficiency on the order of n *

n or n2.

Actually for this version of Selection Sort, the outside for loop runs n - 1

times.

The inside loop runs a number of times based on the outside loop lcv:

During first iteration of outside loop, the inner loop runs n times.

During second iteration of outside loop, the inner loop runs n - 1 times.

During third iteration of outside loop, the inner loop runs n - 2 times.

During fourth iteration of outside loop, the inner loop runs n - 3 times.

and so on. 43


Insertion Sort

44

Insertion Sort

Insertion Sort gets its name from the fact that during each “pass”,

the element being sorted is being “inserted” into its proper

position in the array. The position is temporary if other elements

when they are sorted later move the element to a new position.

This is similar to placing cards in your hand in order, as they are

dealt to you one at a time.

The algorithm begins with the second element in the array. If it is

smaller than the first element, then the two elements are

swapped. Next, the third element in the array is tested to see if it

is smaller than the second element. If it is, then the two are

swapped. If the third element was swapped with the second, it is

then tested to see if it is smaller than the first element. If it is,

then they are swapped. The next slide shows an example.45

Insertion SortLet’s say that an array has the following values stored in it with the element 18

stored in index 0:

18 13 6 23

Since Insertion Sort always begins with the second element it starts with 13 to

see is it is smaller than 18. If it is then it swaps.13 and 18.

13 18 6 23 The first pass is over!

As the second pass begins, Insertion Sort checks to see if 6 (above) is less

than 18. If it is then it swaps them, so temporarily we have …

13 6 18 23 But the second pass is NOT over!

Then Insertion Sort checks to see if 6 is less than 13. If it is then it swaps

them and we have …

6 13 18 23 The second pass is over!

As the third pass begins, Insertion Sort checks to see if 23 is less than 18. It

isn’t so no swap is made and the third pass is over! 46

Insertion Sortpublic static void insertionSortInts(int[] arr){

swaps = 0;int itemToInsert, j;boolean stillLooking;

for (int k = 1; k < arr.length; k++){

itemToInsert = arr[k];j = k - 1;stillLooking = true;while ((j >= 0) && stillLooking){ if (itemToInsert < arr[j]) {

arr[j + 1] = arr[j];j--;

} else

stillLooking = false;}

arr[j + 1] = itemToInsert;swaps++;

}System.out.println("It took " + swaps + " swaps to sort this array!");

}47

Insertion Sort with String Valuespublic static void insertionSortStrings (String [ ] arr){

swaps = 0;int itemToInsert, j;boolean stillLooking;

for (int k = 1; k < arr.length; k++){

itemToInsert = arr[k];j = k - 1;stillLooking = true;while ((j >= 0) && stillLooking){ if (itemToInsert.compareTo(arr[j]) < 0) {

arr[j + 1] = arr[j];j--;

} else

stillLooking = false;}

arr[j + 1] = itemToInsert;swaps++;

}System.out.println("It took " + swaps + " swaps to sort this array!");

}48

Insertion Sort

Note that the algorithm has a nested for loop structure. If there are n elements

in the array, the outer loop runs approximately n times and the inner for

loop runs approximately n times.

This fact causes this algorithm to have an efficiency on the order of n * n or n2.

Actually for this version of Insertion Sort, the outside for loop runs n - 1 times.

The inside loop runs a number of times based on the outside loop lcv:

During first iteration of outside loop, the inner loop runs 1 time.

During second iteration of outside loop, the inner loop runs 2 times.

During third iteration of outside loop, the inner loop runs 3 times.

During fourth iteration of outside loop, the inner loop runs 4 times.

and so on up to n-1 times on the last iteration of the outside loop.

49


Merge Sort

50

Merge Sort

The Merge Sort algorithm is a divide and conquer algorithm. It

recursively divides the original array into two equal parts It does this

by copying the left half into one temporary array and the right half

into another temporary array. If the size of either array is larger than

two, then it divides them in half again copying the left most part into

another temporary array and the right half into another temporary

array. When the left and right arrays contain only one element each,

then the Merge part of the algorithm places the two elements back

into an array in the correct order. This happens at all levels of

recursion and produces a totally sorted array of elements.

This will be demonstrated for you in class with sorting cups, but it can

be show here on the next slide. 51

Merge SortLet’s say that an array has the following values stored in it with the element 18

stored in index 0. The underlined elements show how they are split in half and how they are merged back together.

18 13 6 23 15 14 9 3

18 13 6 23 15 14 9 3 arrays are split in half

18 13 6 23 15 14 9 3 arrays split in half again

18 13 6 23 15 14 9 3 arrays split in half again

13 18 6 23 14 15 3 9 elements merged in order



With n elements, there are log2n subdivisions. This gives an efficiency of

n*log2n which is better than n*n or n2. This means that Merge Sort is more

efficient than Selection Sort or Insertion Sort which are both n2 sorts. 52

Merge Method CodeFor the AP Exam, you only need to be familiar with the Merge part of the Merge Sort algorithm, so

we will show you only the Merge method here: (this is the first part)

private static void merge (int [] a, int[] temp, int from, int middle, int to){ int i = from, j = middle + 1, k = from;

// While both arrays have elements left unprocessed: while (i <= middle && j <= to) { if (a[i] < a[j]) // compare the first one in each of the two "subarrays" { temp[k] = a[i]; i++; } else { temp[k] = a[j]; j++; } k++; }

53


we will show you only the Merge method here: (this is the second part)

// Copy the tail of the first half, if any, into temp: while (i <= middle) { temp[k] = a[i]; // Or simply temp[k++] = a[i++] i++; k++; }

// Copy the tail of the second half, if any, into temp: while (j <= to) { temp[k] = a[j]; // Or simply temp[k++] = a[j++] j++; k++; }

// Copy temp back into a for (k = from; k <= to; k++) a[k] = temp[k];

} // end merge method 54


we will show you only the Merge method here:

public static void merge (int[ ] a, int[ ] copyBuffer, int low, int middle, int high) {

// initialize i1 and i2 to the first items in each subarrayint i1 = low, i2 = middle + 1;

// Interleave items from the subarrays into the copyBuffer in such a way// that order is maintained.for (int i = low; i <= high; i++){

if (i1 > middle)copyBuffer[i] = a[i2++]; // first subarray exhausted

else if (i2 > high)copyBuffer[i] = a[i1++]; // second subarray exhausted

else if (a[i1] < a[i2])copyBuffer[i] = a[i1++]; // item in first subarray is less

elsecopyBuffer[i] = a[i2++]; // item in second subarray is less

}

for (int i = low; i <= high; i++) // copy sorted items back intoa[i] = copyBuffer[i]; // proper position in a

} // end merge method 55

Search & Sort SummaryAlgorithm How it Works

Sequential Search

Begins at the first of the array and searches sequentially in order to find the target value. The array can be sorted or unsorted. On average the target value will be found in n/2 checks.

Binary Search

Begins at the middle of the array and checks for the target value, returning it if it is found. Otherwise, it excludes the half of the array the target can’t be in and goes to the midpoint of the half of the array it could be in. This continues until the target value is found or not found taking less than or equal to log2n + 1 checks.

The array must be sorted. It is more efficient that Sequential Search for large arrays. It is a divide and conquer algorithm.

Selection Sort

On the first pass, swaps the smallest element into the first index location. On the second pass, swaps the next to smallest element into the second index location, etc. Makes only one swap per pass unless the smallest element for that pass is already in its correct final position. No particular worse case scenario.

Insertion Sort

Begins by placing the second element in order with the first element. On the second pass, places the third element in order with respect to the first two elements, and so on. Similar to placing cards in your hand in order while they are being dealt. Worse case scenario is when the array is in reverse order.

Merge Sort

It is a divide and conquer algorithm. It successively divides an array in half, keeping track of each half along the way until each part contains only one element. It then merges the half arrays back together with the elements in order. It is more efficient than Selection Sort or Insertion Sort.

56

Documents

Chapter 14 Searching and Sorting Section 1 - Sequential or Linear Search Section 2 - Binary Search Section 3 - Selection Sort Section 4 - Insertion Sort