1. CS 206 Introduction to Computer Science II 01 / 28 / 2009 Instructor: Michael Eckmann

2. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 Today’s Topics Questions/comments sorting write code to sort an ArrayList start algorithm analysis

3. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 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: http://math.hws.edu/TMCM/java/xSortLab/

4. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 HW Read handout on Algorithm Analysis and Chapter 5.

5. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 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.

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

7. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 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 3 - 17n 2 + (4/7)n )‏ –exponential functions (e.g. f(n) = 5 n )‏ –factorial functions (e.g. f(n) = n! )‏

8. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 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)‏

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

10. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 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

11. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 Algorithm Analysis Growth rates of functions are different than being able to say one function is less than another –e.g. x 2 + 100 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).

12. Michael Eckmann - Skidmore College - CS 206 - Spring 2009 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.