CS201  Spring 2014  Class 12
Quiz
IOException
 When you open a FileReader(i.e. BufferedReader) it can throw a FileNotFoundException
 When you read from a BufferedReader it can throw an IOException, which is a type Exception
 I've only caught the IOException. Why is Java letting me do this?
 IOException is a superclass of FileNotFoundException!
Exception hierarchy
 There are a lot of Exceptions!
 All Exceptions, inherit from the class Exception
 it's kind of like Object for Exceptions (though remember that Exceptions are classes and actually do inherit from Object)
 If you put:
catch(Exception e){
}
 you will catch *ALL* exceptions that are thrown!
 however, it's better style to specifically list the Exception you're trying to catch
look at the sum method in
AsymptoticsExamples code
 How long will it take to if we pass it an array with 1000 numbers in it? 10,000 numbers?
 We don't know!
 We could time it and find out
 Even if you time it, can you say conclusively how long it will take?
 No!
 Variation from run to run
 Depends on the computer
 etc.
 If I tell you the time it took on 10,000 numbers was x. Could you tell me approximately how long it would take on 20,000 numbers?
 would take about twice as long
 why?
 does a linear pass through the data
 doubling the size of the data, means about twice as much work
Asymptotics
 Precisely calculating the actual cost of a method is tedious and not generally useful
 Different operations take different amounts of time. Even from run to run, things such as caching, etc. will complicate things
 Want to identify categories of algorithmic runtimes
 What we really want to do is compare different algorithms
 Want to know which algorithms will be much worse (or much better) than others
Big O
 We write that an algorithms runtime is O(g(n)) if the runtime can be bounded as n gets larger by some constant times g(n)
 For example, sum is O(n), i.e. linear
look at the lastElement and sumProduct methodd in
AsymptoticsExamples code
 What do they do?
 What are their Big O running times?
 Put another way, how does their runtime grow as you increase the size of the input?
 lastElement
 O(1), aka constant
 no matter how large the array is (assuming .length is a constant time operation) it always does the same amount of work
 sumProduct
 O(n^2), aka quadratic
 for each element, it must do a linear amount of work
How does BigO notation allow us to ignore irrelevant details?
 look at the doubleSum method in
AsymptoticsExamples code
 What is the Big O runtime of this method?
 O(n)
 How does it's runtime compare to that of sum?
 twice as long (calls sum twice)
 Even though doubleSum is twice as slow as sum, they're still in the same category since they will roughly grow at the same rate
Show running time table (see pg. 2 of BigO notes from algorithms:
http://www.cs.middlebury.edu/~dkauchak/classes/algorithms/lectures/2_BigO.pdf
)
look at search1 method in
BinarySearchExamples code
 what does this method do?
 what is the running time, using BigO notation?
 depends! sometimes an method/approach always has the same running time
 look at search1a method in
BinarySearchExamples code
 In general, we'll talk about three different things for a method:
 best case running time
 worst case running time
 average case running time
 what are the best, worst and average case running times
 best: O(1), constant, when the example is the first element
 worse: O(n), linear, when the example is the last element
 average: O(n), linear, on average, we'll need to traverse half of the elements (~n/2) which is still O(n)
look at search2 method in
BinarySearchExamples code
 what does this method do?
 uses a helper method
 does the same thing as the previous, but using recursion
 which version is better?
 what is the running time, using BigO notation?
 same as for the iterative version
can we do better than either of these procedures?
 without any preprocessing of the data, no
number guessing game
what if I told you the data was in sorted order?
 how do you find information in a phonebook (where the data is in essence, sorted)?
show binarySearch method in
BinarySearchExamples code
 what does the code do?
 keeps a low and a high value
 we know that if findMe is in the array, then nums[low] <= findMe <= nums[high]
 picks the middle element between low and high
 compares that middle element to our value and then either finds the data or DISCARDS HALF OF THE REMAINING DATA
 an example
 1, 3, 7, 15, 16, 18, 21, 40, 45, 50
 what's the runningtime?
 best case: O(1) it's the midpoint in the ArrayList
 worst case: not found
 how many times do we iterate through the while loop?
 let's consider the case where the number of elements is a power of 2
 we could always pad it up do the next largest power of 2
 at each iteration we throw away half of the data, n/2, n/4, n/8
 when will it be done?
 when n/2^i = 1
log n/2^i = log 1
log n  log 2^i = 0
log n  2 log i = 0
log n = 2 log i
i = log_2 n
 runtime is O(log_2 n)
 average case: half as many iterations through the while loop... still O(log_2 n)
how would we write a recursive version?
 we'd need a helper method
 rather than keeping low and high as variables, they'll be parameters
 then, rather than adjust them, we just call recursively call our method with smaller values
show binarySearchRecursive in
BinarySearchExamples code
why is binary search useful? The cost to sort data is O(n log n), which is more expensive than just the linear search!
Last comments on binary search
 It‚ is easy to get indices wrong, so be careful!
 "Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky... Professor Donald Knuth (taken from
http://en.wikipedia.org/wiki/Binary_search_algorithm
)

http://googleresearch.blogspot.com/2006/06/extraextrareadallaboutitnearly.html
 How hard is it?
http://portal.acm.org/citation.cfm?doid=358476.358484,
only accessible on campus
 What if we wanted to return the first one in the list?
methods in the different BigO categories:
 O(1), constant time: regardless of the size of the input, there is a fixed amount of
work
 add two 32 bit numbers
 determine if a number is even or odd
 sum the Ô¨Årst 20 elements of an array
 O(log n)  logarithmic: at each iteration of the algorithm, discard some proportion of
the input (often half)
 O(n)  linear: do some constant amount of work on each element of the input
 find an item in an Vector (or ArrayList)
 determine the largest element in the array
 O(n log n): divide and conquer algorithms with a linear amount of work to
recombine
 sorting a list of numbers (with some algorithms)
 FFT
 O(n^2): double nested loops that iterate over the data
 matrix addition
 some other sorting algorithms
 O(2^n)
 Enumerate all possible subsets
 Traveling salesman using dynamic programming
 O(n!)
 Enumerate all permutation
 determinant of a matrix with expansion by minors