Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Input
Algorithm
Output
Analysis of Algorithms
Running Time
The running time of an algorithm varies with the input and typically grows with the input size Average case difficult to determine We focus on the worst case running time
Running Time
Input Size
Analysis of Algorithms
Experimental Studies
Write a program implementing the algorithm Run the program with inputs of varying size and composition Use a method like System.currentTimeMillis() to get an accurate measure of the actual running time Plot the results
9000 8000 7000
i e ( s)
Input ize
4
Analysis of Algorithms
Limitations of Experiments
It is necessary to implement the algorithm, which may be difficult Results may not be indicative of the running time on other inputs not included in the experiment. In order to compare two algorithms, the same hardware and software environments must be used
Analysis of Algorithms 5
Theoretical Analysis
Uses a high-level description of the algorithm instead of an implementation Takes into account all possible inputs Allows us to evaluate the speed of an algorithm independent of the hardware/software environment
Analysis of Algorithms
Pseudocode
Example: find max High-level description element of an array of an algorithm More structured than Algorithm arrayMax(A, n) English prose Input array A of n integers Less detailed than a Output maximum element of A program currentMax n A[0] Preferred notation for for i n 1 to n 1 do describing algorithms if A[i] " currentMax then Hides program design currentMax n A[i] issues return currentMax
Analysis of Algorithms
Pseudocode Details
Control flow
Method call
var.method (arg [, arg])
Return value
return expression
Expressions
n Assignment (like ! in Java) ! Equality testing (like !! in Java) n2 Superscripts and other mathematical formatting allowed
8
Method declaration
Algorithm method (arg [, arg]) Input Output
Analysis of Algorithms
Primitive Operations
Basic computations performed by an algorithm Identifiable in pseudocode Largely independent from the programming language Exact definition not important (we will see why later)
Examples:
Evaluating an expression Assigning a value to a variable Indexing into an array Calling a method Returning from a method
Analysis of Algorithms
7n 1
10
Let T(n) be the actual worst-case running time of arrayMax. We have a (7n 1) e T(n) e b(7n 1) Hence, the running time T(n) is bounded by two linear functions
Analysis of Algorithms 11
Affects T(n) by a constant factor, but Does not alter the growth rate of T(n)
The linear growth rate of the running time T(n) is an intrinsic property of algorithm arrayMax
Analysis of Algorithms 12
Growth Rates
Growth rates of functions:
In a log-log chart, the slope of the line corresponds to the growth rate of the function
T (n )
1E+ 0 1E+28 1E+26 1E+24 1E+22 1E+20 1E+18 1E+16 1E+14 1E+12 1E+10 1E+8 1E+6 1E+4 1E+2 1E+0 1E+0
1E+2
1E+4
1E+6
1E+8
1E+10
n
13
Analysis of Algorithms
Constant Factors
The growth rate is not affected by
Examples
T (n )
1E+26 1E+24 1E+22 1E+20 1E+18 1E+16 1E+14 1E+12 1E+10 1E+8 1E+6 1E+4 1E+2 1E+0 1E+0
Quadrati Quadrati i i ar ar
1E+2
1E+4 n
1E+6
1E+8
1E+10
Analysis of Algorithms
14
Big-Oh Notation
10,000
Given functions f(n) and g(n), we say that f(n) is 1,000 O(g(n)) if there are positive constants 100 c and n0 such that f(n) e cg(n) for n u n0 Example: 2n 10 is O(n)
3n n+ n
10
1 1 10 100 1,000
Analysis of Algorithms
15
10
100
1,000
n
Analysis of Algorithms 16
Classes of Functions
Let {g(n)} denote the class (set) of functions that are O(g(n)) We have {n} {n2} {n3} {n4} {n5} where the containment is strict {n3} {n2} {n}
Analysis of Algorithms 18
Big-Oh Rules
If is f(n) a polynomial of degree d, then f(n) is O(nd), i.e.,
1. 2.
Drop lower-order terms Drop constant factors Say 2n is O(n) instead of 2n is O(n2) Say 3n 5 is O(n) instead of 3n 5 is O(3n)
Analysis of Algorithms
19
We find the worst-case number of primitive operations executed as a function of the input size We express this function with big-Oh notation We determine that algorithm arrayMax executes at most 7n 1 primitive operations We say that algorithm arrayMax runs in O(n) time
Example:
Since constant factors and lower-order terms are eventually dropped anyhow, we can disregard them when counting primitive operations
Analysis of Algorithms 20
35 30 25 20 15 10 5 0 1 2 3 5 6 7
X A
21
Arithmetic Progression
7
The running time of prefixAverages1 is O(1 2 n) The sum of the first n integers is n(n 1) 2
6 5 4 3 2 1 0 1 2 3 4 5
23
Analysis of Algorithms
#operations
n 1 n n n 1