COSC 236 Section 101 Computer Science 1 -- Prof. Michael A. Soderstrand

Transcription

1 COSC 236 Section 101 Computer Science 1 -- Prof. Michael A. Soderstrand

2 COSC 236 Web Site You will always find the course material at: or or From this site you can click on the COSC-236 tab to download the PowerPoint lectures, the Quiz solutions and the Laboratory assignments. 2

3 3

4 Review of Quiz 21 Use Quiz 20 as your model for the input dialogue Set up the random numbers as specified in item 2, Quiz 21 The main program will use: int inversions = inversion(array); To count the inversions. Next calculate the percent The main program prints out the array, inversions and percent Finally, you need to write the method inversion to count the inversions (using Lecture 20 slide 65) 4

5 Review of Quiz 21 import java.util.*; The input dialogue: 1. Prompt for the size of the array 2. Get size from console and create the array public class Quiz21 { public static void main(string[] args) { Scanner console = new Scanner(System.in); System.out.print("How many random integers do you want? "); int number = console.nextint(); double[] array = new double[number]; // array to store random numbers System.out.print("What is the minimum number? "); int min = console.nextint(); System.out.print("What is the maximum number? "); int max = console.nextint(); int range = max - min +1; 3. Prompt for minimum 4. Get minimum from console 5. Prompt for maximum 6. Get maximum from console 7. Set random numbers 5

6 Review of Quiz 21 Complete the main program: Random r = new Random(); for (int i = 0; i < number; i++) { // generate random number array[i] = r.nextint(range) + min; int inversions = inversion(array); double percent = 200.0*inversions/number/(number-1); System.out.printf("Original array = %s contains %d inversions (%.1f%s).\n", Arrays.toString(array), inversions, percent, "%"); NOTE: Trick to print out % in printf statement 1. Create random object 2. Fill array with random numbers 3. Calculate inversions 4. Calculate percent 5. Print results 6

7 Review of Quiz 21 Method inversion(): public static int inversion(double[] data) { int count = 0; for (int i = 0; i < data.length - 1; i++) { for (int j = i + 1; j < data.length; j++) { if (data[i] > data[j]) { count++; return count; 1. Returns integer (# of inversions) 2. Accepts an array 3. Initialize the inversion count 4. Optimized inversion algorithm 5. Returns inversion count 7

8 Review of Quiz 21 import java.util.*; public class Quiz21 { public static void main(string[] args) { Scanner console = new Scanner(System.in); System.out.print("How many random integers do you want? "); int number = console.nextint(); double[] array = new double[number]; // array to store random numbers System.out.print("What is the minimum number? "); int min = console.nextint(); System.out.print("What is the maximum number? "); int max = console.nextint(); int range = max - min +1; Random r = new Random(); Complete Program: for (int i = 0; i < number; i++) { // generate random number array[i] = r.nextint(range) + min; int inversions = inversion(array); double percent = 200.0*inversions/number/(number-1); System.out.printf("Original array = %s contains %d inversions (%.1f%s).\n", Arrays.toString(array), inversions, percent, "%"); public static int inversion(double[] data) { int count = 0; for (int i = 0; i < data.length - 1; i++) { for (int j = i + 1; j < data.length; j++) { if (data[i] > data[j]) { count++; // System.out.println("(" + data[i] + ", " + data[j] + ")"); return count; This program is suitable for copy and paste to DrJava 8

9 Review of Quiz 21 OUTPUT: This is the array of random numbers printed out using Arrays.toString() This is the actual number of inversions in the array This is the percentage of inversions in the array 9

10 Review of Quiz 21 OUTPUT: If the percent of inversions is 0%, the array is sorted in ascending order If the percent of inversions is 100%, the array is sorted in descending order This array is nearly a perfect random array (50% inversions) With only 10 elements in the array, your results can vary greatly from the ideal 50% 10

11 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 13.2 Program Complexity Introduction (pp ) Empirical Analysis (pp ) Complexity Classes (pp ) 11

12 Introduction (pp ) In this chapter we ll look at ways to use Java s class libraries to search and sort data. We ll practice implementing some searching and sorting algorithms and talk more generally about how to observe and analyze the runtimes of algorithms. 12

13 Introduction (pp ) Since we have skipped a number of chapters: There will be things in this chapter that we have not covered (part of COSC-237) We will either ignore these or mention them briefly Our goal is to explore searching and sorting which we can do with what we have already covered 13

14 Introduction (pp ) How could we search an array to find the index of a particular value (target)? A simple approach would be to start at the beginning of the array (index = 0) and search sequentially until we found the desired value (target) This is called a sequential search The nice thing about a sequential search is that it works on any array whether sorted or unsorted 14

15 Introduction (pp ) Sequential search sequential search: Locates a target value in an array/list by examining each element from start to finish. How many elements will it need to examine? Example: Searching the array below for the value 42: index value i Notice that the array is sorted. Could we take advantage of this? Target found at index = elements were searched 15

16 Introduction (pp ) Binary search (13.1) binary search: Locates a target value in a sorted array/list by successively eliminating half of the array from consideration. How many elements will it need to examine? Example: Searching the array below for the value 42: Target found at index = 10 index value Only 3 elements were searched min mid max 16

17 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 13.2 Program Complexity Introduction (pp ) Empirical Analysis (pp ) Complexity Classes (pp ) 17

18 Introduction (pp ) Binary Search(pp ) 18

19 Binary Search(pp ) An algorithm that searches for a value in a sorted list by repeatedly dividing the search space in half The Binary Search Algorithm looks at the center element and determines if the target is below or above the center The algorithm then discards the half where the target does not lie and repeats the process on the half where the target does lie 19

20 Binary Search(pp ) Let s search for the number 73 in a sorted array of integers 20

21 Binary Search(pp ) Let s search for the number 73 in a sorted array of integers Discard lower region 21

22 Binary Search(pp ) Let s search for the number 73 in a sorted array of integers Discard upper region 22

23 Binary Search(pp ) Let s search for the number 73 in a sorted array of integers Discard lower region 23

24 Binary Search(pp ) Let s search for the number 73 in a sorted array of integers Discard lower region 24

25 Binary Search(pp ) Let s search for the number 73 in a sorted array of integers Discard lower region The number must be 73 25

26 Binary Search(pp ) Java includes a binary search method for arrays: import java.util.*; Returns the index of the location in the array numbers of the target integer 29 public class Lecture22S23 { public static void main(string[] args) { int[] numbers = {-3, 2, 8, 12, 17, 29, 44, 58, 79; int index = Arrays.binarySearch(numbers, 29); System.out.println("29 is found at index " + index); 26

27 Binary Search(pp ) Java includes a binary search method for arrays: import java.util.*; public class Lecture22S23 { public static void main(string[] args) { int[] numbers = {-3, 2, 8, 12, 17, 29, 44, 58, 79; int index = Arrays.binarySearch(numbers, 29); System.out.println("29 is found at index " + index); Output from program using binary sort However, this only works for sorted arrays If the array is not sorted, we must sort the array before the binary search 27

28 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 13.2 Program Complexity Introduction (pp ) Empirical Analysis (pp ) Complexity Classes (pp ) 28

29 Introduction (pp ) Binary Search(pp ) Sorting (pp ) 29

30 Sorting (pp ) We already know that Java has a sort method: import java.util.*; public class Lecture22S30 { public static void main(string[] args) { int[] numbers = {79, 17, -3, 2, 8, 58, 12, 44, 29; System.out.println("Original array: " + Arrays.toString(numbers)); Arrays.sort(numbers); System.out.println(" Sortedl array: " + Arrays.toString(numbers)); int index = Arrays.binarySearch(numbers, 29); System.out.println("29 is found at index " + index); 30

31 Sorting (pp ) We already know that Java has a sort method: import java.util.*; public class Lecture22S30 { public static void main(string[] args) { int[] numbers = {79, 17, -3, 2, 8, 58, 12, 44, 29; System.out.println("Original array: " + Arrays.toString(numbers)); Arrays.sort(numbers); System.out.println(" Sorted array: " + Arrays.toString(numbers)); int index = Arrays.binarySearch(numbers, 29); System.out.println("29 is found at index " + index); Start with an unsorted array Print out the original unsorted array Use Java Arrays.sort() 31

32 Sorting (pp ) We already know that Java has a sort method: import java.util.*; Print out the sorted array to confirm that it is sorted Invoke the binary search to look for the integer 29 in the array numbers Print out the result of the binary search public class Lecture22S30 { public static void main(string[] args) { int[] numbers = {79, 17, -3, 2, 8, 58, 12, 44, 29; System.out.println("Original array: " + Arrays.toString(numbers)); Arrays.sort(numbers); System.out.println(" Sorted array: " + Arrays.toString(numbers)); int index = Arrays.binarySearch(numbers, 29); System.out.println("29 is found at index " + index); 32

33 Sorting (pp ) We already know that Java has a sort method: import java.util.*; public class Lecture22S30 { public static void main(string[] args) { int[] numbers = {79, 17, -3, 2, 8, 58, 12, 44, 29; System.out.println("Original array: " + Arrays.toString(numbers)); Arrays.sort(numbers); System.out.println(" Sortedl array: " + Arrays.toString(numbers)); int index = Arrays.binarySearch(numbers, 29); System.out.println("29 is found at index " + index); the sorted array But we do not know the index in the original unsorted array The binary search finds the index in 33

34 The Arrays class Class Arrays in java.util has many useful array methods: Method name binarysearch(array, value) binarysearch(array, minindex, maxindex, value) copyof(array, length) equals(array1, array2) fill(array, value) sort(array) tostring(array) Description returns the index of the given value in a sorted array (or < 0 if not found) returns index of given value in a sorted array between indexes min /max - 1 (< 0 if not found) returns a new resized copy of an array returns true if the two arrays contain same elements in the same order sets every element to the given value arranges the elements into sorted order returns a string representing the array, such as "[10, 30, -25, 17]" Syntax: Arrays.methodName(parameters) 34

35 Arrays.binarySearch // searches an entire sorted array for a given value // returns its index if found; a negative number if not found // Precondition: array is sorted Arrays.binarySearch(array, value) // searches given portion of a sorted array for a given value // examines minindex (inclusive) through maxindex (exclusive) // returns its index if found; a negative number if not found // Precondition: array is sorted Arrays.binarySearch(array, minindex, maxindex, value) The binarysearch method in the Arrays class searches an array very efficiently if the array is sorted. You can search the entire array, or just a range of indexes (useful for "unfilled" arrays such as the one in ArrayIntList) If the array is not sorted, you may need to sort it first 35

36 Using binarysearch // index int[] a = {-4, 2, 7, 9, 15, 19, 25, 28, 30, 36, 42, 50, 56, 68, 85, 92; int index = Arrays.binarySearch(a, 0, 16, 42); // index1 is 10 int index2 = Arrays.binarySearch(a, 0, 16, 21); // index2 is -7 binarysearch returns the index where the value is found if the value is not found, binarysearch returns: -(insertionpoint + 1) where insertionpoint is the index where the element would have been, if it had been in the array in sorted order. To insert the value into the array, negate insertionpoint + 1 int indextoinsert21 = -(index2 + 1); // 6 36

37 Binary search code // Returns the index of an occurrence of target in a, // or a negative number if the target is not found. // Precondition: elements of a are in sorted order public static int binarysearch(int[] a, int target) { int min = 0; int max = a.length - 1; while (min <= max) { int mid = (min + max) / 2; if (a[mid] < target) { min = mid + 1; else if (a[mid] > target) { max = mid - 1; else { return mid; return -(min + 1); Algorithm proceeds until min is greater than max Calculate new middle // target found // target not found If the target is above the middle, change minimum to one more than middle. If the target is below the middle, change maximum to one less than middle Target found return middle Target not found, return insertion point (location where target should be) 37

38 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 13.2 Program Complexity Introduction (pp ) Empirical Analysis (pp ) Complexity Classes (pp ) 38

39 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) 39

40 Shuffling (pp ) The task of shuffling data, or rearranging the elements into a random order, is perhaps the opposite of sorting. Why would one want to do this? One application for shuffling is a card game program. You might have a card deck stored as a list of Card objects. If the cards are in a predictable order, the game will be boring. You d like to shuffle the deck of cards, rearranging them into a random ordering each time. This is a case in which chaos is preferable to order. 40

41 Shuffling (pp ) Another application is a situation in which you want a random permutation of a list of numbers. You can acquire a random permutation of the numbers from 1 through 5, for example, by storing those numbers into a list and shuffling the list. The Collections class has a method called shuffle that accepts a list as its parameter and rearranges its elements randomly. 41

42 Shuffling (pp ) import java.util.*; public class Lecture22S42 { public static void main(string[] args) { String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"; String[] suits = {"Clubs", "Diamonds", "Hearts", "Spades"; List<String> deck = new ArrayList<String>(); for (String rank : ranks) { // build sorted deck for (String suit : suits) { deck.add(rank + " of " + suit); Collections.shuffle(deck); System.out.println("Top card = " + deck.get(0)); Specify a string array with the desired order for the ranks Specify a string array with the desired order for the suits Create ArrayList object (See Chapter 10) Build deck sorted by rank and suit Shuffle the deck Display the top card 42

43 Shuffling (pp ) import java.util.*; public class Lecture22S42 { public static void main(string[] args) { String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"; String[] suits = {"Clubs", "Diamonds", "Hearts", Each "Spades"; time you run the List<String> deck = new ArrayList<String>(); for (String rank : ranks) { // build sorted deck program, a new card will for (String suit : suits) { appear at random deck.add(rank + " of " + suit); Collections.shuffle(deck); System.out.println("Top card = " + deck.get(0)); 43

44 Shuffling (pp ) import java.util.*; public class Lecture22S42 { public static void main(string[] args) { String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"; String[] suits = {"Clubs", "Diamonds", "Hearts", "Spades"; List<String> deck = new ArrayList<String>(); for (String rank : ranks) { // build sorted deck for (String suit : suits) { deck.add(rank + " of " + suit); Collections.shuffle(deck); System.out.println("Top card = " + deck.get(0)); 44

45 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 13.2 Program Complexity Introduction (pp ) Empirical Analysis (pp ) Complexity Classes (pp ) 45

46 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 46

47 Custom Ordering with Comparators (pp ) Recall the problem of sorting strings in alphabetical order: String[] strings = {"Foxtrot", "alpha", "echo", "golf", "bravo", "hotel", "Charlie", "DELTA"; Arrays.sort(strings); System.out.println(Arrays.toString(strings)); 47

48 Custom Ordering with Comparators (pp ) Recall the problem of sorting strings in alphabetical order: String[] strings = {"Foxtrot", "alpha", "echo", "golf", "bravo", "hotel", "Charlie", "DELTA"; Arrays.sort(strings); System.out.println(Arrays.toString(strings)); In situations such as these, you can define your own external comparison functions with an object called a comparator. 48

49 Custom Ordering with Comparators (pp ) Use of comparator to do case insensitive sort: // sort Strings using case-insensitive Comparator String[] strings = {"Foxtrot", "alpha", "echo", "golf", "bravo", "hotel", "Charlie", "DELTA"; Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER); System.out.println(Arrays.toString(strings)); 49

50 Binary search and objects Can we binarysearch an array of Strings? Operators like < and > do not work with String objects. But we do think of strings as having an alphabetical ordering. natural ordering: Rules governing the relative placement of all values of a given type. comparison function: Code that, when given two values A and B of a given type, decides their relative ordering: A < B, A == B, A > B 50

51 The compareto method (10.2) The standard way for a Java class to define a comparison function for its objects is to define a compareto method. Example: in the String class, there is a method: public int compareto(string other) A call of A.compareTo(B) will return: a value < 0 if A comes "before" B in the ordering, a value > 0 if A comes "after" B in the ordering, or 0 if A and B are considered "equal" in the ordering. 51

52 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 13.2 Program Complexity Introduction (pp ) Empirical Analysis (pp ) Complexity Classes (pp ) 52

53 Introduction (pp ) Binary Search(pp ) Sorting (pp ) Shuffling (pp ) Custom Ordering with Comparators (pp ) 13.2 Program Complexity Introduction (pp ) 53

54 13.2 Program Complexity Introduction (pp ) Runtime complexity is a measure of the computer resources used by running the code Empirical analysis consists of running the code to see how long it takes Algorithm analysis looks at the code itself and mathematically calculates the efficiency 54

55 Runtime Efficiency (13.2) efficiency: A measure of the use of computing resources by code. can be relative to speed (time), memory (space), etc. most commonly refers to run time Assume the following: Any single Java statement takes the same amount of time to run. A method call's runtime is measured by the total of the statements inside the method's body. A loop's runtime, if the loop repeats N times, is N times the runtime of the statements in its body. 55

56 Efficiency examples statement1; statement2; statement3; 3 for (int i = 1; i <= N; i++) { statement4; for (int i = 1; i <= N; i++) { statement5; statement6; statement7; N 3N 4N

57 Efficiency examples 2 for (int i = 1; i <= N; i++) { for (int j = 1; j <= N; j++) { statement1; for (int i = 1; i <= N; i++) { statement2; statement3; statement4; statement5; N 2 4N N 2 + 4N How many statements will execute if N = 10? If N = 1000? 57

58 Algorithm growth rates (13.2) We measure runtime in proportion to the input data size, N. growth rate: Change in runtime as N changes. Say an algorithm runs 0.4N N 2 + 8N + 17 statements. Consider the runtime when N is extremely large. We ignore constants like 25 because they are tiny next to N. The highest-order term (N 3 ) dominates the overall runtime. We say that this algorithm runs "on the order of" N 3. or O(N 3 ) for short ("Big-Oh of N cubed") 58

59 Complexity classes complexity class: A category of algorithm efficiency based on the algorithm's relationship to the input size N. Class Big-Oh If you double N,... Example constant O(1) unchanged 10ms logarithmic O(log 2 N) increases slightly 175ms linear O(N) doubles 3.2 sec log-linear O(N log 2 N) slightly more than doubles 6 sec quadratic O(N 2 ) quadruples 1 min 42 sec cubic O(N 3 ) multiplies by 8 55 min exponential O(2 N ) multiplies drastically 5 * years 59

60 Collection efficiency Efficiency of various operations on different collections: Method ArrayList SortedIntList Stack Queue add (or push) O(1) O(N) O(1) O(1) add(index, value) O(N) - - indexof O(N) O(?) - - get O(1) O(1) - - remove O(N) O(N) O(1) O(1) set O(1) O(1) - - size O(1) O(1) O(1) O(1) 60

61 Binary search (13.1, 13.3) binary search successively eliminates half of the elements. Algorithm: Examine the middle element of the array. If it is too big, eliminate the right half of the array and repeat. If it is too small, eliminate the left half of the array and repeat. Else it is the value we're searching for, so stop. Which indexes does the algorithm examine to find value 22? What is the runtime complexity class of binary search? index value

62 Binary search runtime For an array of size N, it eliminates ½ until 1 element remains. N, N/2, N/4, N/8,..., 4, 2, 1 How many divisions does it take? Think of it from the other direction: How many times do I have to multiply by 2 to reach N? 1, 2, 4, 8,..., N/4, N/2, N Call this number of multiplications "x". 2 x = N x = log 2 N Binary search is in the logarithmic complexity class. 62

63 Range algorithm What complexity class is this algorithm? Can it be improved? // returns the range of values in the given array; // the difference between elements furthest apart // example: range({17, 29, 11, 4, 20, 8) is 25 public static int range(int[] numbers) { int maxdiff = 0; // look at each pair of values for (int i = 0; i < numbers.length; i++) { for (int j = 0; j < numbers.length; j++) { int diff = Math.abs(numbers[j] numbers[i]); if (diff > maxdiff) { maxdiff = diff; return diff; 63

64 Range algorithm 2 The algorithm is O(N 2 ). A slightly better version: // returns the range of values in the given array; // the difference between elements furthest apart // example: range({17, 29, 11, 4, 20, 8) is 25 public static int range(int[] numbers) { int maxdiff = 0; // look at each pair of values for (int i = 0; i < numbers.length; i++) { for (int j = i + 1; j < numbers.length; j++) { int diff = Math.abs(numbers[j] numbers[i]); if (diff > maxdiff) { maxdiff = diff; return diff; 64

65 Range algorithm 3 This final version is O(N). It runs MUCH faster: // returns the range of values in the given array; // example: range({17, 29, 11, 4, 20, 8) is 25 public static int range(int[] numbers) { int max = numbers[0]; // find max/min values int min = max; for (int i = 1; i < numbers.length; i++) { if (numbers[i] < min) { min = numbers[i]; if (numbers[i] > max) { max = numbers[i]; return max - min; 65

66 Runtime of first 2 versions Version 1: Version 2: 66

67 Runtime of 3rd version Version 3: 67

68 Assignments for this week 1. Laboratory for Chapter 7 due today Monday 11/17 IMPORTANT: When you me your laboratory Word Document, be sure it is all in one file 2. Read pp (Chapter 13) for Wednesday 11/19 3. Be sure to complete Quiz 22 before leaving class tonight This is another program to write You must demonstrate the program to me before you leave lab 68