Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Comparing Objects in Java • boolean result = obj1.equals(obj2); • int diff = obj1.compareTo(obj2); • int diff = c.compare(obj1, obj2); 14-1 obj1.equals(obj2) (cont’d) • equals is called polymorphically from library methods, such as ArrayList’s contains or indexOf that is why we have to properly override Object’s equals. • The equals method is properly defined in String, Integer, Double, etc. 14-2 obj1.compareTo(obj2) • compareTo is an abstract method defined in the java.util.Comparable<T> interface: public int compareTo (T other); • Returns a positive integer if obj1 is T is the type parameter “greater than” obj2, a negative integer if obj1 is “less than” obj2, zero if they are “equal.” Sort of like obj1 - obj2 14-3 obj1.compareTo(obj2) (cont’d) • compareTo is called polymorphically from library methods, such as Arrays.binarySearch(Object[ ] arr). • Objects of classes that implement Comparable are called “comparable” (pronounced com-'parable). • Strings, Integers, Doubles are comparable. 14-4 obj1.compareTo(obj2) (cont’d) «interface» Comparable<String> «interface» Comparable<Integer> «interface» Comparable<Double> String Integer Double compareTo is based on lexicographical order compareTo is based on numerical values 14-5 Sequential Search • Scans the list comparing the target value to each element. Dan 0 Fay 1 Cal 2 Ben 3 Guy 4 Amy 5 Amy? Amy? Amy? Amy? Amy? Amy! Eve 6 14-6 Sequential Search (cont’d) public int sequentialSearch(Object [ ] arr, Object target) { for (int i = 0; i < arr.length ; i++) { if (target.equals(arr [i])) return i; } return -1; } For primitive data types it is if (value == arr [ i ]) 14-7 Sequential Search (cont’d) • The average number of comparisons (assuming the target value is equal to one of the elements of the array, randomly chosen) is about n / 2 (where n = arr.length). • Worst case: n comparisons. • Also n comparisons are needed to establish that the target value is not in the array. • We say that this is an O(n) (order of n) algorithm. 14-8 Binary Search • The elements of the list must be arranged in ascending (or descending) order. • The target value is always compared with the middle element of the remaining search range. • We must have random access to the elements of the list (an array or ArrayList are OK). 14-9 Binary Search (cont’d) Amy 0 Ben 1 Cal 2 Dan 3 Eve 4 Fay 5 Guy 6 Eve 4 Fay 5 Guy 6 Eve? Amy 0 Ben 1 Cal 2 Dan 3 Eve? Amy 0 Ben 1 Cal 2 Dan 3 Eve 4 Fay 5 Guy 6 Eve! 14-10 Binary Search (cont’d) • Recursive implementation: public int binarySearch (int [ ] arr, int value, int left, int right) { if (right < left) return -1; // Not found int middle = (left + right) / 2; if (value == arr [middle] ) return middle; else if (value < arr[middle]) return binarySearch (arr, value, left, middle - 1); else // if ( value > arr[middle]) return binarySearch (arr, value, middle + 1, right); } 14-11 Binary Search (cont’d) • Iterative implementation: public int binarySearch (int [ ] arr, int value, int left, int right) { while (left <= right) { int middle = (left + right) / 2; if ( value == arr [middle] ) return middle; else if ( value < arr[middle] ) right = middle - 1; else // if ( value > arr[middle] ) left = middle + 1; } return -1; // Not found } 14-12 Binary Search (cont’d) • A “divide and conquer” algorithm. • Works very fast: only 20 comparisons are needed for an array of 1,000,000 elements; (30 comparisons can handle 1,000,000,000 elements; etc.). • We say that this is an O(log n) algorithm. 14-13 Sorting • To sort means to rearrange the elements of a list in ascending or descending order. • Examples of sorting applications: a directory of files sorted by name or date bank checks sorted by account # addresses in a mailing list sorted by zip code hits found by a search engine sorted by relevance credit card transactions sorted by date 14-14 Sorting (cont’d) • The algorithms discussed here are based on “honest” comparison of values stored in an array. No tricks. • How fast can we sort an array of n elements? If we compare each element to each other we need n(n-1) / 2 comparisons (that is, n2 by the “order of magnitude.”) Faster “divide and conquer” sorting algorithms need approximately n·log2 n comparisons (much better). 14-15 Sorting (cont’d) Time n2 n log2 n n n n2 n log2 n 10 100 35 100 10,000 700 1000 1,000,000 10,000 14-16 Selection Sort 1. Select the max among the first n elements: 1 13 8 5 2 1 3 n 2. Swap it with the n-th element : 1 3 8 5 2 1 13 n 3. Decrement n by 1 and repeat from Step 1 (while n > 1) 1 3 8 5 n 2 1 13 14-17 Selection Sort (cont’d) • Iterative implementation: public void selectionSort (double [ ] arr, int n) { while (n > 1) { int maxPos = 0; for (int k = 1; k < n; k++) if (arr [k] > arr [maxPos] ) maxPos = k; double temp = arr [maxPos]; swap a[maxPos] arr [maxPos] = arr [n-1]; and a[n-1] arr [n-1] = temp; n--; } } 14-18 Selection Sort (cont’d) • The total number of comparisons is always (n-1) + (n-2) + ... + 1 = n(n-1) / 2 • No average, best, or worst case — always the same. • An O(n2) algorithm. 14-19 Insertion Sort 1. k = 1; keep the first k elements in order. 2. Take the (k+1)-th element and insert among the first k in the right place. 2 13 1 8 1 3 5 k 3. Increment k by 1; repeat from Step 2 (while k < n) 1 2 3 5 13 1 8 k 14-20 Insertion Sort (cont’d) • Iterative implementation: public void insertionSort (double [ ] arr, int n) { for (int k = 1 ; k < n; k++) { double temp = arr [ k ]; int i = k; while (i > 0 && arr [i-1] > temp) { arr [i] = arr [i - 1]; i --; } arr [i] = temp; } } shift to the right 14-21 Insertion Sort (cont’d) • The average number of comparisons is roughly half of the number in Selection Sort. • The best case is when the array is already sorted: takes only (n-1) comparisons. • The worst case is n(n-1) / 2 when the array is sorted in reverse order. • On average, an O(n2) algorithm. 14-22 Mergesort 1. Split the array into two roughly equal “halves.” 5 1 3 2 4 7 6 2. Sort (recursively) each half using... Mergesort. 1 3 5 2 4 6 7 3. Merge the two sorted halves together. 1 3 1 2 3 2 4 5 6 7 The smaller value goes first 14-23 Mergesort (cont’d) public void mergesort (double[ ] arr, int from, int to) { if (from <= to) return; int middle = (from + to ) / 2; mergesort (arr, from, middle); mergesort (arr, middle + 1, to); if (arr [middle] > arr [middle + 1]) { copy (arr, from, to, temp) ; merge (temp, from, middle, to, arr); } } Base case Optional shortcut: “if not yet sorted”... double[ ] temp is initialized outside the mergesort method 14-24 Mergesort (cont’d) • Takes roughly n·log2 n comparisons. • Without the shortcut, there is no best or worst case. • With the optional shortcut, the best case is when the array is already sorted: takes only (n-1) comparisons. • An O(n log n) algorithm. 14-25 Quicksort 1. Pick one element, called “pivot” 5 1 6 2 4 7 3 2. Partition the array, so that all the elements to the left of pivot are pivot; all the elements to the right of pivot are pivot. 4 1 3 2 5 7 6 3. Sort recursively the left and the right segments using... Quicksort. 14-26 Quicksort (cont’d) • Takes roughly n·log2 n comparisons. • May get slow if pivot consistently fails to split the array into approximately equal halves. • An O(n log n) algorithm. 14-27 The Benchmarks program Enter the array size Choose the sorting algorithm Running time in milliseconds 14-28 java.util.Random • Benchmarks uses the java.util.Random class — a more controlled way to generate random numbers. • Constructors: the seed is different each time Random generator1 = new Random( ); Random generator2 = new Random(seed); long seed; • If we set the same seed, we get the same “random” sequence. 14-29 java.util.Random (cont’d) • Methods: int k = generator.nextInt (n); 0k<n double x = generator.nextDouble ( ); 0x<1 14-30 java.util.Arrays • Provides static methods for dealing with arrays. • Works for arrays of numbers, Strings, and Objects. • Methods: int pos = Arrays.binarySearch (arr, target); Arrays.sort (arr); Arrays.fill (arr, value); // fills arr with a given value String str = Arrays.toString(arr); Arrays.asList(arr); Returns a representation of arr as a fixed-length list 14-31 java.util.Collections • Provides static methods for dealing with ArrayLists and other Java collections. • Works for arrays of numbers, Strings, and Objects. • Methods: int pos = Collections.binarySearch (list, target); Collections.sort (list); Collections.shuffle (list); 14-32 Review: • What is the type of the parameter in the equals method? • How many methods are listed in the Comparable interface? • What is a comparator? • How many comparisons are needed in the worst case to find the target value among 15 values using Sequential Search? Using Binary Search? 14-33 Review (cont’d): • Describe briefly the main idea of Selection Sort. • Describe briefly the main idea of Insertion Sort. • Is it easier to implement Mergesort recursively or iteratively? • What is the average number of comparisons in Mergesort? • Name a few methods of the java.util.Arrays class. 14-34