SEARCHING AND SORTING

1. SEARCHING AND SORTING

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

3. Searching

4. 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?

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

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

7. Linear Search with Strings // Suppose we have an array of names (Strings) int linearSearch(String[] stuff, String searchValue) { for(int i=0; i<stuff.length; i++) { if (stuff[i].equals(searchValue)) // OR if (stuff[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 ==

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

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

10. open LinearSearch.java LinearSearchTester.java

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

12. Binary Search 0100100101

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

14. 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).

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

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

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

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

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

20. open BinarySearch.java BinarySearchTester.java

21. The Selection Sort

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

23. Selection Sort 0 1 2 3 4 original pass 1 pass 2 pass 3 pass 4 Array length is 5. Number of passes = 5 – 1 = 4

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

25. 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? Selection Sort W/Objects (ascending)

26. 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; } } Selection Sort W/Objects (descending)

27. 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 4030 2010

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

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

30. open SelectionSort.java SelectionSortTester.java

31. The Insertion Sort

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

33. 2 9 8 5 1 2 8 9 5 1 2 5 8 9 1 1 2 5 8 9 Insertion Sort 0 1 2 3 4 original after pass 1 after pass 2 after pass 3 after pass 4 Blue signifies elements checked during the pass. They are sorted relative to each other. Highlighted element is the one inserted during the pass.

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

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

36. 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; } }

37. 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:http://cg.scs.carleton.ca/~morin/misc/sortalg/ • Racing different sort algorithmshttp://www.cs.bme.hu/~gsala/alg_anims/2/sortchoiceinp.html • Java sorting overview:http://www.javamex.com/tutorials/collections/sorting_java_algorithm_performance.shtml

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

39. open InsertionSort.java InsertionSortTester.java

40. Java Sorts and Searches

41. This is the array sort method you should use in your programs. It uses a Quicksort algorithm.

42. This is the sort method you should use for ArrayLists It uses a Mergesort algorithm.

43. Java Searches OUTPUT -12-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)); int[] ray = {3,4,5,6,11,18,91}; System.out.println(Arrays.binarySearch(ray,15));

44. Java Sorts 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-526131718

45. Java Sorts 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-1231321

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

47. 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); OUTPUTSue AdamsJoe BassTom JonesBob SmithSara Weiss • Athlete object class needs to implement Comparable • Have to redefine compareTo() method • toString() method will make the print work as desired

48. 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]

49. open SortArray.java

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