CS 206 Introduction to Computer Science II 09 / 05 / 2008 Instructor: Michael Eckmann

Michael Eckmann - Skidmore College - CS Fall 2008 Today’s Topics More Java Review Let's write the code that will sort the ArrayList of Cards. Also, for more experience, let's put the equals method in the Card class (to be used instead of == to actually compare the data stored in the Card objects.)‏ Start Algorithm Analysis (chapter 5)‏

Michael Eckmann - Skidmore College - CS Fall 2008 Programming Examples Let's write a simple insertion sort method to sort the Cards in the ArrayList. To remind ourselves of how insertion sort works, let's look at:

Michael Eckmann - Skidmore College - CS Fall 2008 equals public boolean equals(Object o)‏ { if (o instanceof Card)‏ { Card c = (Card) o; return ((c.suit == this.suit) && (c.rank == this.rank)); } else return false; }

Michael Eckmann - Skidmore College - CS Fall 2008 equals Things to make sure you understand: –which Card is which --- One card calls equals (this) and one card is passed in as a parameter (o). –why can I refer to private suit and rank instance variables? –what is the purpose of the if (o instanceof Card) check? –Does it really return true if the cards are equal and false if they are not? How? –Why is an equals method necessary at all --- why not just use something like (c1 == c2) instead of (c1.equals(c2))? –This method overrides the equals method in Object so it had to have had the same signature what's a signature?

Michael Eckmann - Skidmore College - CS Fall 2008 HW Read handout on Algorithm Analysis and Chapter 5.

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis An algorithm is a specific set of instructions for solving a problem. The amount of time an algorithm takes to finish is often proportional to the amount of input –sorting 1 million items vs. sorting 10 items –searching a list of 2 billion items vs. searching a list of 3 items Problem vs. algorithm --- a problem is not the same as an algorithm. Example: Sorting is a problem. An algorithm is a specific recipe for solving a problem. –bubbleSort, insertionSort, etc. are different algorithms for sorting. So, when we're analyzing the running time --- we're analyzing the running time of an algorithm, not a problem.

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis Algorithms are often analyzed for –the amount of time they take to run and/or –the amount of space used while running

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis Some common functions (in increasing order) used in analysis are –constant functions (e.g. f(n) = 10 )‏ –logarithmic functions (e.g. f(n) = log(20n) )‏ –log squared (e.g. f(n) = log 2 (7n) )‏ –linear functions (e.g. f(n) = 3n – 9 )‏ –N log N (e.g. f(n) = 2n log n )‏ –quadratic functions (e.g. f(n) = 5n 2 + 3n )‏ –cubic functions (e.g. f(n) = 3n n 2 + (4/7)n )‏ –exponential functions (e.g. f(n) = 5 n )‏ –factorial functions (e.g. f(n) = n! )‏

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis The dominant term is what gives a function it's name among –cubic, quadratic, logarithmic, etc. It's more complex than this, but the dominant term can generally be picked out like: –if you determine a function for the running time of an algorithm to be say f(n) = log 2 n + 4n 3 it's dominant term is 4n 3 so ignoring constant multiplier, we have n 3 –we say that f(n) is O (n 3 ) (pronounced big-Oh en cubed)‏ An example of when it's a bit harder to determine –f(n) = 3n log(n!) + (n 2 + 3)log n is O(n 2 logn)‏

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis Graphs of functions to get a more intuitive feel for the growth of functions, take a look at the handout with graphs.

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis Let's look at the tables with examples of actual times for certain running times given large inputs shows that the time complexity of an algorithm is much more important than processor speed (for large enough inputs) even though processor speeds are getting faster exponentially

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis Growth rates of functions are different than being able to say one function is less than another –e.g. x is greater than x 3 for many initial values but as x increases above some value, x 3 will always be bigger The constant being multiplied by the dominant term is generally ignored (except for small amounts of input)‏ Big O notation ignores the constant multipliers of the dominant term and we say a phrase like: –linear search is big Oh en –when we mean that the linear search algorithm's time complexity grows linearly (based on n, the number of items in the search space).

Michael Eckmann - Skidmore College - CS Fall 2008 Algorithm Analysis When examining an algorithm, we usually count how many times a certain operation (or group of operations) is performed. See handout for reasonable choices of what operations we would count in different problems. This will lead us to determining the time complexity of the algorithm. We can consider best-case, worst-case and average-case scenarios.