1. Sorting and Searching Pepper

2. Common Collection and Array Actions Sort in a certain order ◦ Max ◦ Min Shuffle Search ◦ Sequential (contains) ◦ Binary Search –  assumes sort, faster

3. Static Method Tools Classes Arrays ◦ binarySearch (array, value) ◦ sort(array) Collections ◦ binarySearch (list, value) ◦ shuffle(list) ◦ sort(list) ◦ max(list) ◦ min(list)

4. Sorting – need order Comparable interface ◦ Only one order – chosen as natural order ◦ Implemented inside order  Implements Comparable ◦ int compareTo (SelfType o)  int compareTo (Object o)  Compare this item to the parm ◦ Used automatically by Collections sort ◦ Used automatically by TreeMap and TreeSet

5. Sorting – Custom Order Comparator ◦ Custom order ◦ Independent of the object's definition  Uses 2 objects and compares them  int compare (Selftype s1, Selftype s2)  No this  just 2 input objects to compare ◦ Implements comparator  Outside the class being sorted ◦ Why  Collections sort can use it  TreeSet can use it  TreeMap can use it

6. The Comparator Interface Syntax to implement ◦ public class lengthCom implements Comparator {  public int compare(String s1, String s2){  Return s1.length() = s2.length(); }} Sorted list: dog, cat, them, bunnies

7. How to use the Comparator Collections sort can take in a comparator ◦ Passed to methods as an extra parm ◦ Object passed into Collections.sort ◦ Ex: Collections.sort(myarray, new myArraySorter()) Use ◦ Arrays.sort(stringArray, new lengthCom()); ◦ Collections.sort(stringList, new lengthCom()); ◦ new TreeSet (new lengthCom());

8. Stock Comparators String ◦ CASE_INSENSITIVE_ORDER Collections ◦ reverseOrder() – returns comparator ◦ reverseOrder(comparator object)  Returns opposite order of comparator Use ◦ Collections.sort(myStringList, CASE_INSENSITIVE_ORDER) ◦ Collections.sort(myStringList, Collections.reverseOrder(new lengthCom()))

9. Searching and Sorting Searching and Sorting Complexity measuring Search algorithms Sort algorithms

10. Complexity Measurements Empirical – log start and end times to run ◦ Over different data sets Algorithm Analysis ◦ Assumed same time span (though not true):  Variable declaration and assignment  Evaluating mathematical and logical expressions  Access or modify an array element  Non-looping method call

11. How many units – worst case: Sample code – find the largest value var M = A[ 0 ]; //lookup 1, assign 1 for ( var i = 0; i < n; i++) { // i = o 1; test 1 // retest 1; i++ 1; if ( A[ i ] >= M ) { // test 1 ; lookup 1 M = A[ i ];}} // lookup 1, assign 1 4 + 2n + 4n F(n) = 4 + 2n + 4n = 4 + 6n Fastest growing term with no constant: F(n) = n (n is your array size) http://discrete.gr/complexity/

12. Practice with asymptote finding – no constant f( n ) = n 2 + 3n + 112 gives f( n ) = n 2 f( n ) = n + sqrt(n) gives f( n ) = n F(n) = 2 n + 12 gives f(n) = 2 n F(n) = 3 n + 2 n gives f(n) = 3 n ◦ Just test with large numbers

13. Practice with asymptote finding (dropping constant) f( n ) = 5n + 12 gives f( n ) = n. ◦ Single loop will be n; ◦ called linear f( n ) = 109 gives f( n ) = 1. ◦ Need a constant 1 to show not 0 ◦ Means no repetition ◦ Constant number of instructions

14. Determining f(n) for loops for (i = 0; i < n; i++) for (j = 0; j < n; j++) for (k = 0; k < n; k++) System.out.println(a[i][j][k]);}}} F(n) = n 3

15. Big O Notation – Growth Rate F(n) = n 3 gives Big O Notation of O( n 3 ) Which will be slower than O(n) Which will be slower than O(1)

16. Searching Sequential : ◦ Go through every item once to find the item ◦ Measure worst case ◦ 0(N)

17. Binary Search First Sorted Dictionary type search – keep looking higher or lower Takes 0 seconds, but cannot be O(1) because it has a loop As input grows, number of times to divide min-max range grows as: ◦ 2 repetitions is approximately the Number of elements in the array ◦ So, repetitions = log 2 N -  O(log 2 N)

18. Binary Search code public static int findTargetBinary(int[] arr, int target){ int min = 0; int max = arr.length - 1; while( min <= max) { int mid = (max + min) / 2; if (arr[mid] == target){ return mid; } else if (arr[mid] < target) { min = mid + 1; } else { max = mid - 1; } } return -1; }

19. Selection Sort Find the smallest value's index Place the smallest value in the beginning via swap Repeat for the next smallest value Continue until there is no larger value Go through almost every item in the array for as many items as you have in the array ◦ Complexity: O (N 2 )

20. Bubble Sort Initial algorithm Check every member of the array against the value after it; if they are out of order swap them. As long as there is at least one pair of elements swapped and we haven’t gone through the array n times: If the data is in order, it can be as efficient as O(n) or as bad as O(n 2 )

21. Merge Sort Two sorted subarrays can quickly be merged into a sorted array. Divide the array in half and sort the halves. Merge the halves. Picture: http://www.java2novice.com/java- sorting-algorithms/merge-sort/http://www.java2novice.com/java- sorting-algorithms/merge-sort/ Video: http://math.hws.edu/TMCM/java/xSortLab / http://math.hws.edu/TMCM/java/xSortLab /

22. Merge Sort Complexity Split array in half repeatedly until each subarray contains 1 element. ◦ 2 repetitions is approximately the Number of elements in the array ◦ So, repetitions of division= log 2 N ◦ O(log N) At each step, do a merge, go through each element once ◦ O(N) Together: O (N log 2 N)

23. Comparison speed Sequential Search - O(N) Binary Search - O(log2 N) Selection Sort - O(N2) Bubble Sort - O(N2) Merge Sort - O (N log2 N) https://www.ics.uci.edu/~eppstein/161/960116.html

24. Summary Relative complexity – O Notation Arrays and Collections class Different Search methods ◦ Sequential Search – keep looking one by one ◦ Binary Search – dictionary type split search Different Sort methods ◦ Selection Sort – look through all to find smallest and put it at the beginning – repeatedly ◦ Bubble Sort – continual swapping pairs – repeatedly ◦ Merge Sort - continually divide and sort then merge