2. 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

3. Searches and Sorts There 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

4. Chapter 14 - Section 1 Sequential or Linear Search 3

5. 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

6. Sequential Search of an Array of ints Only 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

7. Sequential Search of an Array of ints The 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 checked if (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

8. Sequential Search of a 2D Array of ints A 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

9. Sequential Search of an Array of Strings The 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) { for (int i = 0; i < arr.length; i++) { if ( arr [ i ]. equals (target) ) { return i; // if found return the index of the target value } return -1; // if target value NOT found return -1 } 8

10. Sequential Search of an Array of Students The 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) { for (int i = 0; i < arr.length; i++) { if ( arr [ 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 not any different from the code for searching strings because the Student class has an equals method. 9

11. Sequential Search of an ArrayList of Students The 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 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

12. Chapter 14 - Section 2 Binary Search 11

13. Binary Search Binary 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

14. Binary Search Code public 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

15. 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

16. Binary Search Because 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 log 2 n. 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? log 2 8 which is equal to log 2 (2 3 ) 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

17. Binary Search’s Efficiency is log 2 n + 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 1 st, 2 nd, or 3 rd 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

18. The Number of Checks for Binary Search So 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 … log 2 (8) or log 2 (2 3 ) = 3 checks 8 – 15 elements takes … log 2 (16) or log 2 (2 4 ) = 4 checks 16 – 31 elements takes … log 2 (32) or log 2 (2 5 ) = 5 checks 32 - 63 elements takes … log 2 (64) or log 2 (2 6 ) = 6 checks 64 - 127 elements takes … log 2 (128) or log 2 (2 7 ) = 7 checks This can be summarized in general as:log 2 n + 1 So you can see when n is 8 it takes 4 checks: log 2 8 + 1 = 3 + 1 = 4 17

19. Recursive Binary Search 18

20. 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

21. Efficiency of the Searches The 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 log 2 n 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 CaseWorst CaseAverage Case Sequential1 checkn checksn / 2 checks Binary1 checklog 2 n checks 20

22. Chapter 14 - Section 3 Selection Sort 21

23. Selection Sort Selection 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

24. 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

25. Selection Sort Let’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. Selection Sort finds that the next smallest element is in index 4, so it swaps 13 with the first element in the part of the array still being sorted, 18. 6 8 13 23 18 Third pass over! 13 is out of the sorting process. Selection Sort finds that the next smallest element is in index 4, so it swaps 18 with the first element in the part of the array still being sorted, 23. 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

26. Selection Sort Ascending Order for ints public 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

27. Selection Sort Descending Order for ints public 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++; } System.out.println("It took " + swaps + " swaps using Selection Sort!"); } 26

28. 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

29. 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

30. Sect 6 - int compareTo (String other) 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

31. Sect 6 - int compareTo (String other) 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) 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); 30

32. 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”; 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); 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.

33. Sect 6 - int compareTo (String other) In this code, word1 is the receiver object this and word2 is other. String word1 = “a”; String word2 = “c”; 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); Output: “a comes before b” Note: “a”.compareTo(“c”) returns -2 based on the Unicode values for “a” and “c” … 97 - 99 = -2 32

34. Sect 6 - int compareTo (String other) In this code, word1 is the receiver object this and word2 is other. String word1 = “apple”; String word2 = “banana”; 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); 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

35. Sect 6 - int compareTo (String other) In this code, word1 is the receiver object this and word2 is other. String word1 = “b”; String word2 = “a”; 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); Output: “b comes after a” Note: “b”.compareTo(“a”) returns +1 based on the Unicode values for “b” and “a” … 98 - 97 = 1 34

36. Sect 6 - int compareTo (String other) In this code, word1 is the receiver object this and word2 is other. String word1 = “d”; String word2 = “a”; 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); Output: “b comes after a” Note: “d”.compareTo(“a”) returns +3 based on the Unicode values for “d” and “a” … 100 - 97 = 3 35

37. Sect 6 - int compareTo (String other) In this code, word1 is the receiver object this and word2 is other. String word1 = “bear”; String word2 = “bearcats”; 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); 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

38. Sect 6 - int compareTo (String other) In this code, word1 is the receiver object this and word2 is other. String word1 = “bearclaw”; String word2 = “bearcats”; 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); Output: “banana comes after apple” 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

39. Sect 6 - int compareTo (String other) In this code, word1 is the receiver object this and word2 is other. String word1 = “bearcats”; String word2 = “bearclaw”; 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); Output: “banana comes after apple” 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

40. 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 Let’s look at what a compareTo method of the Person class would look like on the next slide. 39

41. CompareTo Method for the Person class public 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

42. The Selection Sort Code for Strings public 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; int temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex]= temp; swaps++; } System.out.println("It took " + swaps + " swaps using Selection Sort!"); } 41

43. The Selection Sort Code for Students public 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; int temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex]= temp; swaps++; } System.out.println("It took " + swaps + " swaps using Selection Sort!"); } 42

44. Selection Sort Note 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 n 2. 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

45. Chapter 14 - Section 4 Insertion Sort 44

46. 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

47. Insertion Sort Let’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

48. Insertion Sort public 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

49. Insertion Sort with String Values public 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

50. 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 n 2. 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

51. Chapter 14 - Section 5 Merge Sort 50

52. 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

53. Merge Sort Let’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 13 18 6 23 14 15 3 9 elements merged in order 6 13 18 23 3 9 14 15 elements merged in order 3 6 9 13 14 15 18 23 elements merged in order With n elements, there are log 2 n subdivisions. This gives an efficiency of n*log 2 n which is better than n*n or n 2. This means that Merge Sort is more efficient than Selection Sort or Insertion Sort which are both n 2 sorts. 52

54. Merge Method Code For 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

55. Merge Method Code For 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 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

56. Merge Method Code For 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: public static void merge (int[ ] a, int[ ] copyBuffer, int low, int middle, int high) { // initialize i1 and i2 to the first items in each subarray int 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 else copyBuffer[i] = a[i2++];// item in second subarray is less } for (int i = low; i <= high; i++) // copy sorted items back into a[i] = copyBuffer[i];// proper position in a } // end merge method 55

57. Search & Sort Summary AlgorithmHow 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