4.1, 4.2: Analysis of Algorithms

Transcription

1 Overview 4.1, 4.2: Analysis of Algorithms Analysis of algorithms: framework for comparing algorithms and predicting performance. Scientific method.! Observe some feature of the universe.! Hypothesize a model that is consistent with observation.! Predict events using the hypothesis.! Verify the predictions by making further observations.! Validate the theory by repeating the previous steps until the hypothesis agrees with the observations. Universe = computer itself. Introduction to Computer Science Robert Sedgewick and Kevin Wayne 2 Algorithmic Successes Case Study: Sorting -body Simulation.! Simulate gravitational interactions among bodies.! Brute force: 2 steps.! Barnes-Hut: log steps, enables new research. Discrete Fourier transform.! Break down waveform of samples into periodic components. Applications: DVD players, JPEG, analysis of astronomical data, medical imaging, nonlinear Schrödinger equation,.! Brute force: 2 steps.! FFT algorithm: log steps, enables new technology. Sorting.! Rearrange items in ascending order.! Fundamental information processing abstraction. Andrew Appel PU '81 Freidrich Gauss 1805 Sorting problem:! Given items, rearrange them in ascending order.! Applications: statistics, databases, data compression, computational biology, computer graphics, scientific computing, name Hauser Hong Hsu Hayes Haskell Hanley Hornet name Hanley Haskell Hauser Hayes Hong Hornet Hsu Jon von eumann IAS

2 Insertion Sort Helper Functions Insertion sort.! Brute-force sorting solution.! Move left-to-right through array.! Exchange next element with larger elements to its left, one-by-one. public static void insertionsort(double[] a) { int = a.length; for (int i = 0; i < ; i++) { for (int j = i; j > 0; j--) { if (less(a[j], a[j-1])) exch(a, j, j-1); else break; Sorting helper functions.! Is real number x strictly less than y? public static boolean less(double x, double y) { return (x < y);! Swap real numbers stored in a[i] and a[j]. public static void exch(double[] a, int i, int j) { double swap = a[i]; a[i] = a[j]; a[j] = swap; 5 6 Insertion Sort: Observation Insertion Sort: Experimental Hypothesis Observe and tabulate running time for various values of.! Data source: random numbers between 0 an 1.! Machine: Apple G5 1.8GHz with 1.5GB memory running OS X.! Timing: Skagen wristwatch. Data analysis. Plot # comparisons vs. input size on log-log scale. 5,000 10,000 20,000 80, million 25 million 99 million 400 million 16 million 0.13 seconds 0.43 seconds 1.5 seconds 5.6 seconds 23 seconds Regression. Fit line through data points! a b. Hypothesis. # comparisons grows quadratically with input size! 2 /4. slope 7 8

3 Insertion Sort: Prediction and Verification Insertion Sort: Validation Experimental hypothesis. # comparisons! 2 /4. Prediction. 400 million comparisons for = 20,000. Observations. umber of comparisons depends on input family.! Ascending:.! Random: 2 /4.! Descending: 2 / million sec million sec Agrees million sec million sec Prediction. 10 billion comparisons for = 200,000. Observation. 200, billion 145 seconds Agrees Insertion Sort: Theoretical Hypothesis Insertion Sort: Theoretical Hypothesis Experimental hypothesis.! Measure running times, plot, and fit curve.! Model useful for predicting, but not for explaining. Worst case. (descending)! Iteration i requires i comparisons.! Total = = (-1) / 2. Theoretical hypothesis.! Analyze algorithm to estimate # comparisons as a function of: number of elements to sort average or worst case input! Model useful for predicting and explaining.! Model is independent of a particular machine or compiler. E F G H I J D C B A i Average case. (random)! Iteration i requires i/2 comparisons on average.! Total = 0 + 1/2 + 2/ (-1)/2 = (-1) / 4. Difference. Theoretical model can apply to machines not yet built. A C D F H J E B I G i 11 12

4 Insertion Sort: Theoretical Hypothesis Quicksort Theoretical hypothesis. Quicksort.! Partition array so that: Analysis Stddev some partitioning element a[m] is in its final position Worst Average 2 / 2 2 / 4 A 1/6 3/2 no larger element to the left of m no smaller element to the right of m Best A Validation. Theory agrees with observations. Remark. Supercomputer can't rescue a bad algorithm. partitioning element Q U I C K S O R T I S C O O L Computer Per Second Thousand Million Billion I C K I C L Q U S O R T S O O laptop 10 7 instant 1 day 3 centuries " L # L super instant 1 second 2 weeks partitioned array Quicksort Quicksort: Java Implementation Quicksort.! Partition array so that: some partitioning element a[m] is in its final position no larger element to the left of m no smaller element to the right of m! Sort each "half" recursively. Quicksort.! Partition array so that: some partitioning element a[m] is in its final position no larger element to the left of m no smaller element to the right of m! Sort each "half" recursively. partitioning element Q U I C K S O R T I S C O O L CI C KI I CK L QO OU OS QO R TS S OT OU public static void quicksort(double[] a, int left, int right) { if (right <= left) return; int i = partition(a, left, right); quicksort(a, left, i-1); quicksort(a, i+1, right); sort each piece 16 17

5 Quicksort : Implementing Partition Quicksort: Observation Q. How to partition in-place efficiently? Observe and tabulate running time for various values of.! Data source: first words of Charles Dicken's life work.! Machine: Apple G5 1.8GHz with 1.5GB memory running OS X. public static int partition(double[] a, int left, int right) { int i = left - 1; int j = right; 200, million 0.10 sec while(true) { while (less(a[++i], a[right])) ; find item on left to swap 400,000 1 million 2 million 9.5 million 26 million 55 million 0.23 sec 0.47 sec 0.96 sec while (less(a[right], a[--j])) if (j == left) break; if (i >= j) break; exch(a, i, j); exch(a, i, right); return i; check if pointers cross swap find item on right to swap swap with partitioning element return index where crossing occurs 4 million 120 million 2.0 sec 8 million 240 million 4.2 sec Remark. Takes 1.8 seconds to generate input of size 8 million! Quicksort: Preliminary Hypothesis Insertion Sort: Prediction and Verification Experimental hypothesis. umber of comparisons! 30. Experimental hypothesis. umber of comparisons! 30. Prediction. 120 million comparisons for = 4 million. Observations. 4 million 4 million million million 2.04 sec 2.07 sec Agrees. 4 million million 2.02 sec Prediction. 600 million comparisons for = 20 million. Observations. 20 million 638 million 11.1 sec ot quite. 100 million 3.6 billion 60.6 sec 20 21

6 Quicksort: Theoretical Hypothesis Scientific Method Average case. (random)! umber of comparisons! 2 ln (stddev! 0.65).! umber of exchanges! 1/3 ln. Worst case. umber of comparisons! 1/2 2. Scientific method applies to estimate running time.! Experimental analysis: not difficult to perform experiments.! Theoretical analysis: may require advanced mathematics.! Small subset of mathematical functions suffice to describe running time of many fundamental algorithms. Validation.! Random shuffle before sorting to eliminate worst case.! Alternate: partition on random element.! Theory now agrees with observations. Lesson. Great algorithms can be more powerful than supercomputers. Computer laptop super Per Second Insertion 3 centuries 2 weeks Quicksort 3 hours instant = 1 billion 2 log 2 for (int i = 0; i < ; i++) for (int i = 0; i < ; i++) for (int j = 0; j < ; j++) while ( > 1) { = / 2; 2 log 2 public static void f(int ) { if ( == 0) return; f(-1); f(-1); public static void g(int ) { if ( == 0) return; f(/2); f(/2); for (int i = 0; i < ; i++) Order of Growth Summary Asymptotic running time.! Estimate time as a function of input size.! Ignore lower order terms and leading coefficients. when is large, terms are negligible when is small, we don't care! Ex: is asymptotically proportional to 3. Complexity 1 Description Constant algorithm is independent of input size. When doubles, running time does not change Donald Knuth How can I evaluate the performance of my algorithm?! Computational experiments.! Theoretical analysis. What if it's not fast enough?! Understand why.! Buy a faster computer.! Find a better algorithm in a textbook.! Discover a new algorithm. log Logarithmic algorithm gets slightly slower as grows. increases by a constant Attribute Better Machine Better Algorithm log Linear algorithm is optimal if you need to process inputs. Linearithmic algorithm scales to huge problems. doubles slightly more than doubles Cost Applicability $$$ or more. Makes "everything" run faster. $ or less. May not apply to some problems. 2 Quadratic algorithm practical for use only on relatively small problems. quadruples Improvement Incremental quantitative improvements. Dramatic quantitative improvements possible. 2 Exponential algorithm is not usually practical. squares! 24 25