What did we talk about last time? Finished hunters and prey Class variables Constants Class constants Started Big Oh notation

Week 12 - Friday

What did we talk about last time? Finished hunters and prey Class variables Constants Class constants Started Big Oh notation

Here is some code that sorts an array in ascending order What is its running time? for( int i = 0; i < array.length; i++ ) for( int j = 0; j < array.length - 1; j++ ) if( array[j] > array[j + 1] ) { int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } Running time: O(n 2 )

Here is a table of several different complexity measures, in ascending order, with their functions evaluated at n = 100 Description Big Oh f(100) Constant O(1) 1 Logarithmic O(log n) 6.64 Linear O(n) 100 Linearithmic O(n log n) 664.39 Quadratic O(n 2 ) 10000 Cubic O(n 3 ) 1000000 Exponential O(2 n ) 1.27 x 10 30 Factorial O(n!) 9.33 x 10 157

Computers get faster, but not in unlimited ways If computers get 10 times faster, here is how much a problem from each class could grow and still be solvable Description Big Oh Increase in Size Constant O(1) Unlimited Logarithmic O(log n) 1000 Linear O(n) 10 Linearithmic O(n log n) 10 Quadratic O(n 2 ) 3-4 Cubic O(n 3 ) 2-3 Exponential O(2 n ) Hardly changes Factorial O(n!) Hardly changes

There is nothing better than constant time Logarithmic time means that the problem can become much larger and only take a little longer Linear time means that time grows with the problem Linearithmic time is just a little worse than linear Quadratic time means that expanding the problem size significantly could make it impractical Cubic time is about the reasonable maximum if we expect the problem to grow Exponential and factorial time mean that we cannot solve anything but the most trivial problem instances

Memory usage can be a problem If you run out of memory, your program can crash Memory usage can have serious performance consequences too

Remember, there are multiple levels of memory on a computer Each next level is on the order of 500 times larger and 500 times slower Size 500X 500X Cache Actually on the CPU Fast and expensive RAM Primary memory for a desktop computer Pretty fast and relatively expensive Hard Drive Secondary memory for a desktop computer Slow and cheap Speed 500X 500X

If you can do a lot of number crunching without leaving cache, that will be very fast If you have to fetch data from RAM, that will slow things down If you have to read and write data to the hard drive (unavoidable with large pieces of data like digital movies), you will slow things down a lot

Memory can be easier to estimate than running time Depending on your input, you will allocate a certain number of objects, arrays, and primitive data types It is possible to count the storage for each item allocated Remember that a reference to an object or an array costs an additional 4 bytes on top of the size of the object

Here are the sizes of various types in Java Type Bytes boolean 1 char 2 int 4 double 8 Type boolean[] char[] int[] double[] Bytes 16 + N 16 + 2N 16 + 4N 16 + 8N Type Bytes reference 4 String 40 + 2N object 8 + size of members array of objects 16 + (4 + size of members)n Note that the N refers to the number of elements in the array or String

Lets say that I give you a list of numbers, and I ask you, Is 37 on this list? As a human, you have no problem answering this question, as long as the list is reasonably short What if the list is an array, and I want you to write a Java program to find some number?

Easy! We just look through every element in the array until we find it or run out public static int find( int[] array, int number ) { for( int i = 0; i < array.length; i++ ) if( array[i] == number ) return i; } return -1; If we find it, we return the index, otherwise we return -1

Unfortunately for you, we know about Big Oh notation Now we have some way to measure how long this algorithm takes How long, if n is the length of the array? O(n) time because we have to look through every element in the array, in the worst case

Is there any way to go smaller than O(n)? What complexity classes even exist that are smaller than O(n)? O(1) O(log n) Well, on average, we only need to check half the numbers, that s ½ n which is still O(n) Darn

We can do better with more information For example, if the list is sorted, then we can use that information somehow How? We can play a High-Low game

Repeatedly divide the search space in half We re looking for 37, let s say 23 31 37 54 Check Check the Check middle the Check middle the middle the middle (Too (Too low) (Found low) (Too it!) high)

How long can it take? What if you never find what you re looking for? Well, then, you ve narrowed it down to a single spot in the array that doesn t have what you want And what s the maximum amount of time that could have taken?

We cut the search space in half every time At worst, we keep cutting n in half until we get 1 Let s say x is the number of times we look: 1 x n = 1 2 n = 2 x log n = x The running time is O(log n)

We can apply this idea to a guessing game First we tell the computer that we are going to pick a number between 1 and n We pick, and it tries to narrow down the number It should only take log n tries Remember log 2 (1,000,000) is only about 20

This is a classic interview question asked by Microsoft, Amazon, and similar companies Imagine that you have 9 red balls One of them is just slightly heavier than the others, but so slightly that you can t feel it You have a very accurate two pan balance you can use to compare balls Find the heaviest ball in the smallest number of weighings

It s got to be 8 or fewer We could easily test one ball against every other ball There must be some cleverer way to divide them up Something that is related somehow to binary search

We can divide the balls in half each time If those all balance, it must be the one we left out to begin with

How? They key is that you can actually cut the number of balls into three parts each time We weigh 3 against 3, if they balance, then we know the 3 left out have the heavy ball When it s down to 3, weigh 1 against 1, again knowing that it s the one left out that s heavy if they balance

The cool thing is Yes, this is cool in the CS sense, not in the real sense Anyway, the cool thing is that we are trisecting the search space each time This means that it takes log 3 n weighings to find the heaviest ball We could do 27 balls in 3 weighings, 81 balls in 4 weighings, etc.

Sorting

Finish Project 4 Due tonight before midnight!