SEARCHING AND SORTING

Searching and Sorting on AP Exam Searching Sorting Sequential (Linear) Binary Selection Insertion Merge

Searching

Searching Examples Suppose you have a telephone book and you want to search for a person’s telephone number. You know the person’s first and last name. How difficult is this? Suppose you have the same telephone book and you want to find a person that has a certain telephone number. How would you find it? Why is this more difficult?

Linear / Sequential Search The Linear Search searches through a list sequentially (one element at time) looking for a match. The index position of a match is returned if found or -1 is returned if no match is found. It must go through the entire list in order to determine if there is no match.

Linear Search with Primitives public int linearSearch(int[] nums, int val) { for(int i=0; i< nums.length; i++) if (nums[i] == val ) return i; } return -1; //returns -1 if not found

Linear Search with Strings // Suppose we have an array of names (Strings) public int linearSearch(String[] ray, String searchValue) { for(int i=0; i<ray.length; i++) if (ray[i].equals(searchValue)) // OR if (ray[i].compareTo(searchValue)==0) return i; } return -1; //returns -1 if not found // Note: same as linear search with primitives except // you use equals method instead of ==

Linear Search with Objects // Can be generalized to work with any object, not // only Strings. Just substitute Object for String in // the parameter list public int linearSearch(Object[] ray, Object searchValue) { for(int i=0; i<ray.length; i++) if (ray[i].equals(searchValue)) // OR if (ray[i].compareTo(searchValue)==0) return i; } return -1; //returns -1 if not found

Summary of Linear / Sequential Search The Linear/Sequential Search works fine if the array is relatively small (a few hundred elements). However, if the array is large, it could become slow. Average number of elements searched is n/2, where n is the array length. This search method works fine when the array is sorted or even when it is not sorted.

open LinearSearch.java LinearSearchTester.java

Hint: Sort the array by using Arrays.sort(arrayName); Work on NumberSearch class Hint: Sort the array by using Arrays.sort(arrayName);

Binary Search 0100100101

Binary Search The method of linear search works well for arrays that are fairly small (a few hundred elements). As the array gets very large (thousands or millions of elements), the behavior of the search degrades. When we have an array of elements that are in ascending order, such as a list of numbers or names, there is a much better way to proceed, using an algorithm known as binary search. This method is much faster than linear search for very large arrays.

Binary Search The Binary Search is only guaranteed to work with sorted lists (normally in ascending order). The basic idea of binary search is to examine the element at the array's midpoint on each pass through the search loop. If the current element matches the search value, we return its position If the current element is less than the search value, then we search the part of the array to the right of the midpoint (containing the positions of the greater items).

Binary Search Otherwise, we search the part of the array to the left of the midpoint (containing the positions of the lesser items). On each pass through the loop, the current leftmost position or the current rightmost position is adjusted to track the portion of the array being searched.

Binary Search public int binarySearch (int [] nums, int searchValue ) { int bot= 0, top = nums.length-1; while(bot<=top) int middle = (bot + top) / 2; if (nums[middle] == searchValue ) return middle; else if (nums[middle] > searchValue ) top = middle-1; bot = middle+1; } return -1;

BinarySearch int[] nums = {1, 6, 8, 10, 14, 22, 30, 50}; If you are searching for 25, how many times will you check nums? 1st pass 0 + 7 = 7 / 2 = 3 nums[3] = 10 2nd pass 4 + 7 = 11 / 2 = 5 nums[5] = 22 3rd pass 6 + 7 = 13 / 2 = 6 nums[6] = 30

Binary Search ShortCut Given a list of N items. What is the next largest power of 2? If N is 100, the next largest power of 2 is 7. Log2(100) = 6.64386 27 = 128. It would take 7 checks max to determine if an item existed in a list of 100 items.

Binary Search Example Have 3 volunteers come to the front of the room and look at 3 different telephone books Each volunteer should report the number of pages in the book for that city Each volunteer should look for the same name (for example David Daniels) by simulating a binary search Report how many times they have to check a page before finding the page that contains the name

open BinarySearch.java BinarySearchTester.java

The Selection Sort

Selection Sort Selection sort swaps the current element with the lowest element from the remaining elements in the list. Selection Sort does not swap each time it finds elements out of position. Selection sort makes a complete pass while searching for the next item to swap. At the end of a pass once the item is located, one swap is made.

Array length is 5. Number of passes = 5 – 1 = 4 Selection Sort 0 1 2 3 4 original 9 2 8 5 1 pass 1 1 2 8 5 9 pass 2 1 2 8 5 9 pass 3 1 2 5 8 9 Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop. pass 4 1 2 5 8 9 Array length is 5. Number of passes = 5 – 1 = 4

Selection Sort public void selectionSort( int[] ray ) { for(int i=0; i< ray.length-1; i++) { int min = i; //min = location of lowest value for(int j = i+1; j< ray.length; j++) if(ray[j] < ray[min]) min = j; //find location of lowest value } if( min != i) int temp = ray[min]; ray[min] = ray[i]; ray[i] = temp; //put lowest value in pos i Selection sort is pretty effective for small lists, but pretty horrible if used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop.

How many swaps per pass? Selection Sort W/Objects (ascending) public void selSort(Car[] cars) { for(int i=0; i<cars.length-1; i++) int spot = i; for(int j=i+1; j<cars.length; j++) if(cars[j].compareTo(cars[spot])<0) spot = j; } if(spot==i) continue; //skip remaining lines; go to top of loop Car save = cars[i]; cars[i] = cars[spot]; cars[spot] = save; How many swaps per pass? When using a sort an against object, the object needs to have extended the Comparable interface. The Object class needs to redefine the compareTo() method so that the sort knows how to compare objects. The Comparable interface ony contains one method: compareTo() Selection Sort W/Objects (ascending)

Selection Sort W/Objects (descending) public void selSort(Car[] cars) { for(int i=0; i<cars.length-1; i++) int spot = i; for(int j=i+1; j<cars.length; j++) if(cars[j].compareTo(cars[spot])>0) spot = j; } if(spot==i) continue; //skip remaining lines; go to top of loop Car save = cars[i]; cars[i] = cars[spot]; cars[spot] = save; When using a sort an against object, the object needs to have extended the Comparable interface. The Object class needs to redefine the compareTo() method so that the sort knows how to compare objects. The Comparable interface ony contains one method: compareTo() Selection Sort W/Objects (descending)

Selection Sort in Action (descending order) Original List Integer[] ray = {90,40,20,30,10,67}; pass 1 - 90 40 20 30 10 67 pass 2 - 90 67 20 30 10 40 pass 3 - 90 67 40 30 10 20 pass 4 - 90 67 40 30 10 20 pass 5 - 90 67 40 30 20 10

Summary of Selection Sort Selection sort is pretty effective for small lists, but pretty horrible if used on large lists Selection sort consists of two loops The outer loops run based on the number of items in the list The inner loop runs to find the items that need to be moved Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop.

Summary of Selection Sort The inner loop either locates the spot with the smallest value or the spot with the largest value (depending on whether you are sorting it in ascending or descending order) After the inner loop completes, a swap may occur if needed At most, selection sort will make one swap per pass A pass is one complete execution of the inner loop Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop.

open SelectionSort.java SelectionSortTester.java

The Insertion Sort

Insertion Sort The insertion sort first selects an item and moves items up or down based on the comparison to the selected item. The idea is to get the selected item in proper position by shifting items around in the list. This is analogous to the way some people pick up playing cards and order them in their hands.

Insertion Sort 0 1 2 3 4 original 9 2 8 5 1 after pass 1 1 5 8 9 2 0 1 2 3 4 original 9 2 8 5 1 after pass 1 1 5 8 9 2 after pass 2 1 5 9 8 2 after pass 3 1 9 8 5 2 Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop. after pass 4 9 8 5 2 1 Blue signifies elements checked during the pass. They are sorted relative to each other. Highlighted element is the one inserted during the pass.

Insertion Sort w/primitives public void insertionSort( int[] nums) { for (int i=1; i< nums.length; i++) int val = nums[i]; //item to insert int j=i; while(j>0 && val<nums[j-1]) nums[j] = nums[j-1]; j--; } nums[j]=val; Insertion Sort w/primitives

Insertion Sort w/Strings public void insertionSort( String[] nums ) { for (int i=1; i< nums.length; i++) String val = nums[i]; //item to insert int j=i; while(j>0 && val.compareTo(nums[j-1])<0) nums[j] = nums[j-1]; j--; } nums[j]=val; Insertion Sort w/Strings

Sort Boxes By Volume public class Box implements Comparable { private double volume; //constructor and other methods not listed public int compareTo(Object obj) { Box otherBox = (Box) obj; if (volume < otherBox.volume) return -1; if (volume == otherBox.volume) return 0; return 1; } Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop.

Insertion Sort Animation Sorting cards: http://www.youtube.com/watch?v=gTxFxgvZmQs&NR=1  Sorting bars: http://www.youtube.com/watch?v=kSyJb-EfNVI&feature=related  Demo of Selection sort and insertion sort: http://www.cs.oswego.edu/~mohammad/classes/csc241/samples/sort/Sort2-E.html Comparing many different sort algorithms (includes code): http://cg.scs.carleton.ca/~morin/misc/sortalg/ Racing different sort algorithms http://www.sorting-algorithms.com/ Java sorting overview: http://www.javamex.com/tutorials/collections/sorting_java_algorithm_performance.shtml Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop.

Summary of Insertion Sort Insertion Sort is normally more efficient than a Selection Sort Insertion Sort continually sorts the left side of the list while gradually moving to the end. This type of sort is similar to how many people sort cards in their hands Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop.

open InsertionSort.java InsertionSortTester.java

Java Sorts and Searches

frequently used methods for arrays Arrays class frequently used methods for arrays Name Use sort(x) puts all items in array x in ascending order binarySearch(x,y) Prerequisite: array x must be sorted. Checks x for the location of y. This method returns the index where y is found. If y is not found, it returns -1 minus the position in the array list where x would be added. equals(x,y) checks if arrays x and y have same values fill(x, y) fills all spots in array x with value y The Arrays class methods above are very useful methods for manipulating Java arrays. sort() will naturally order the items in an array. binarySearch() will find an item in the array and return the spot at which the item was found. equals() will see if two arrays contain the exact same items in the exact same order. fill() will fill in all spots in the array with a provided value. This is the array sort method you should use in your programs. It uses a Quicksort algorithm.

frequently used methods for array lists Collections class frequently used methods for array lists Name Use sort(x) puts all items in array list x in ascending order binarySearch(x,y) Prerequisite: array list x must be sorted. Checks x for the location of y. This method returns the index where y is found. If y is not found, it returns -1 minus the position in the array list where x would be added. fill(x,y) fills all spots in array list x with value y rotate(x,y) shifts items in array list x left or right y spots reverse(x) reverses the order of the items in array list x The Collections class methods above are very useful methods for manipulating Java Collections. sort() will naturally order the items in the collection. binarySearch() will find an item in the array and return the spot at which the item was found. fill() will fill in all spots in the array with a provided value. rotate() will shift items to the left(- negative x) a specified amount or shift items to the right(+ positive x) a specified amount. reverse() will reverse the order of all items. This is the sort method you should use for ArrayLists It uses a Mergesort algorithm.

Java Searches OUTPUT -1 2 -6 String s = "abcdefghijklmnop"; System.out.println(s.indexOf(“R")); int[] ray = {3,4,5,6,11,18,91}; System.out.println(Arrays.binarySearch(ray,5)); System.out.println(Arrays.binarySearch(ray,15)); indexOf() and binarySearch() seach and array for specified value. indexOf() will return the spot at which the item was found. It will return -1 if the item was not present. binarySearch() will return the spot at which the item was found. It will return -1 - location(where the item should be) if the item was not present.

Java Sorts OUTPUT-5 2 6 13 17 18 int[] ray = {13,6,17,18,2,-5}; Arrays.sort(ray); for(int i = 0; i < ray.length; i++) { System.out.println(ray[i]); } OUTPUT-5 2 6 13 17 18 sort() will naturally order the items in an array. This sort uses the Quicksort sorting algorithm.

Java Sorts OUTPUT-1 2 3 13 21 ArrayList<Integer> ray; ray=new ArrayList<Integer>(); ray.add(21); ray.add(2); ray.add(13); ray.add(-1); ray.add(3); Collections.sort(ray); for(int num : ray ) System.out.println(num); OUTPUT-1 2 3 13 21 sort() will naturally order the items in the Collection.

Sorting Objects public class Athlete implements Comparable { private String lastName, firstName; //constructor and other methods not listed public int compareTo(Object obj) { Athlete otherAthlete = (Athlete) obj; if (lastName.compareTo(other Athlete.lastName)<0) return -1; if (lastName.compareTo(other Athlete.lastName)>0) return 1; return 0; } Selection sort is pretty effective for small lists, but pretty horrible is used on large lists. Selection sort consists of two loops. The outer loops run based on the number of items in the list. The inner loop runs to find the items that need to be moved. The inner loop either locates the spot with the smallest value or the spot with the largest value. After the inner loop completes, a swap may occur if needed. At most, selection sort will make one swap per pass. A pass is one complete execution of the inner loop.

Sorting Objects ArrayList<Athlete> list; list=new ArrayList<Athlete>(); list.add(new Athlete(“Bob”,”Smith”)); list.add(new Athlete(“Tom”,”Jones”)); list.add(new Athlete(“Sue”,”Adams”)); list.add(new Athlete(“Joe”,”Bass”)); list.add(new Athlete(“Sara”,”Weiss”)); Collections.sort(list); for(Athlete athlete : list ) System.out.println(athlete); OUTPUT Sue Adams Joe Bass Tom Jones Bob Smith Sara Weiss sort() will naturally order the items in the Collection. Athlete object class needs to implement Comparable Have to redefine compareTo() method toString() method will make the print work as desired

Sorting an Array int[] intArray = {9, 2, 4, -12}; Arrays.sort(intArray); // [-12, 2, 4, 9] String[] strArray = {"y", "b", "H"}; Arrays.sort(strArray); // [H, b, y] // Case-insensitive sort Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); // [b, H, y] // Reverse-order sort Arrays.sort(strArray, Collections.reverseOrder()); // [y, b, H] // Case-insensitive reverse-order sort Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); Collections.reverse(Arrays.asList(strArray)); // [y, H, b] sort() will naturally order the items in an array. This sort uses the Quicksort sorting algorithm.

open SortArray.java

CashRegister Widget Corp. Store A Store B Store C Register 1 Money Money Money Money Money Money Money Money

i++ and ++i OUTPUT 10 10 20 OUTPUT 10 20 20 What is the difference? i++ assigns i value before incrementing: int[] array = {10, 20, 30, 40}; i = 0; System.out.println(array[i]); System.out.println(array[i++]); ++i assigns i value after incrementing: int i = 0; System.out.println(array[++i]); OUTPUT 10 10 20 OUTPUT 10 20 20 sort() will naturally order the items in an array. This sort uses the Quicksort sorting algorithm.

Divide and Conquer Algorithms 32 16 16 8 8 8 8 4 4 4 4 4 4 4 4

The Merge Sort

Merge Sort Merge sort splits the list into smaller sections working its way down to groups of two or one. Once the smallest groups are reached, the merge method is called to organize the smaller lists. Merge copies from the sub list to a temp array. The items are put in the temp array in sorted order.

Merge Sort 1 . . 32 1 . . 16 17 . . 32 1 . . 8 9. . 16 17 . .25 26 . . 32 Merge sort chops in half repeatedly to avoid processing the whole list at once.

mergeSort Algorithm Collections.sort( ) uses mergeSort. public void mergeSort(Comparable[] ray, int front, int back) { int mid = (front+back)/2; if(mid==front) return; mergeSort(ray, front, mid); mergeSort(ray, mid, back); merge(ray, front, back); } Collections.sort( ) uses mergeSort. Arrays.sort( ) uses mergeSort for objects.

public void merge(Comparable[] ray, int front, int back) { Comparable[] temp = new Comparable[back-front]; int i = front, j = (front+back)/2, k =0, mid =j; while( i<mid && j<back) if(ray[i].compareTo(ray[j])<0) temp[k++]= ray[i++]; else temp[k++]= ray[j++]; } while(i<mid) while(j<back) for(i = 0; i<back-front; ++i) ray[front+i]=temp[i]; Merge W/Objects

Merge Sort in Action Original List Integer[] ray = {90,40,20,30,67,10}; pass 1 - 90 20 40 30 67 10 pass 2 - 20 40 90 30 67 10 pass 3 - 20 40 90 30 10 67 pass 4 - 20 40 90 10 30 67 pass 5 - 10 20 30 40 67 90

The mergeSort method alone has a Log2N run time, but cannot be run without the merge method. The merge method alone has an N run time and can be run without the mergeSort method. mergeSort Merge

open MergeSort.java

Racing the Sort Algorithms: Speed Racing the Sort Algorithms: http://www.sorting-algorithms.com/

Sort Algorithm Comparisons Name Best Case Avg. Case Worst Selection Sort Insertion Sort Merge Sort @ If the data is sorted, Insertion sort should only make one pass through the list. If this case is present, Insertion sort would have a best case of O(n).