1 / 24

Sorting and Searching

Sorting and Searching. Pepper. Common Collection and Array Actions. Sort in a certain order Max Min Shuffle Search Sequential (contains) Binary Search – assumes sort, faster. Static Method Tools Classes. Arrays binarySearch (array, value) sort(array) Collections

rene
Download Presentation

Sorting and Searching

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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<T> • 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<T> • 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<String>{ • 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<String> (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 • 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 ) = n2 + 3n + 112 gives f( n ) = n2 • f( n ) = n + sqrt(n) gives f( n ) = n • F(n) = 2n + 12 gives f(n) = 2n • F(n) = 3n + 2n gives f(n) = 3n • F(n) = 3n + 2n gives f(n) = 3n • 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) = n3

  15. Big O Notation – Growth Rate • F(n) = n3 gives Big O Notation of O( n3 ) • 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: • 2repetitions is approximately the Number of elements in the array • So, repetitions = log2N - O(log2 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 (N2)

  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(n2)

  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/ • Video: http://math.hws.edu/TMCM/java/xSortLab/

  22. Merge Sort Complexity • Split array in half repeatedly until each subarray contains 1 element. • 2repetitions is approximately the Number of elements in the array • So, repetitions of division= log2N • O(log N) • At each step, do a merge, go through each element once • O(N) • Together: O (N log2 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

More Related