Algorithms Pseudocode Analysis
Algorithms Pseudocode Analysis
Analysis of Algorithms 1
Average Case vs. Worst Case
Running Timeof an algorithm
• An algorithm may run faster on certain data sets than on others.
• Finding the average case can be very difficult, so typically
algorithms are measured by the worst-case time complexity.
• Also, in certain application domains (e.g., air traffic control,
surgery, IP lookup) knowing the worst-case time complexity is of
crucial importance.
5 ms worst-case
4 ms
3 ms
}
average-case?
best-case
2 ms
1 ms
Analysis of Algorithms 2
A B C D E F G
Input
Measuring the Running Time
• How should we measure the running time of an algorithm?
• Approach 1: Experimental Study
– Write a program that implements the algorithm
– Run the program with data sets of varying size and composition.
– Use a method like System.currentTimeMillis() to get an accurate
measure of the actual running time.
t (ms)
60
50
40
30
20
10
Analysis of Algorithms 3
n
0 50 100
Beyond Experimental Studies
Analysis of Algorithms 4
Beyond Experimental Studies
• We will now develop a general methodology for
analyzing the running time of algorithms. In
contrast to the "experimental approach", this
methodology:
– Uses a high-level description of the algorithm instead of
testing one of its implementations.
– Takes into account all possible inputs.
– Allows one to evaluate the efficiency of any algorithm in a
way that is independent from the hardware and software
environment.
Analysis of Algorithms 5
Pseudo-Code
• Pseudo-code is a description of an algorithm that is more structured
than usual prose but less formal than a programming language.
• Example: finding the maximum element of an array.
Algorithm arrayMax(A, n):
Input: An array A storing n integers.
Output: The maximum element in A.
currentMax A[0]
for i 1 to n -1 do
if currentMax < A[i] then currentMax A[i]
return currentMax
• Pseudo-code is our preferred notation for describing algorithms.
• However, pseudo-code hides program design issues.
Analysis of Algorithms 6
What is Pseudo-Code ?
• A mixture of natural language and high-level programming concepts that
describes the main ideas behind a generic implementation of a data structure or
algorithm.
-Expressions: use standard mathematical symbols to describe numeric and
boolean expressions -use for assignment (“=” in Java)
-use = for the equality relationship (“==” in Java)
-Method Declarations: -Algorithm name(param1, param2)
-Programming Constructs: - decision structures: if ... then ... [else ... ]
- while-loops: while ... do
- repeat-loops: repeat ... until ...
- for-loop: for ... do
- array indexing: A[i]
-Methods: - calls: object method(args)
- returns: return value
Analysis of Algorithms 7
Analysis of Algorithms
• Primitive Operations: Low-level computations
independent from the programming language can be
identified in pseudocode.
• Examples:
– calling a method and returning from a method
– arithmetic operations (e.g. addition)
– comparing two numbers, etc.
• By inspecting the pseudo-code, we can count the number
of primitive operations executed by an algorithm.
8
Example:
Algorithm arrayMax(A, n):
Input: An array A storing n integers.
Output: The maximum element in A.
currentMax ¨ A[0]
for i ¨ 1 to n -1 do
if currentMax < A[i] then
currentMax A[i]
return currentMax
Analysis of Algorithms 9
Asymptotic Notation
• Goal: to simplify analysis by getting rid of
unneeded information (like “rounding”
1,000,001≈1,000,000)
• We want to say in a formal way 3n 2 ≈ n2
• The “Big-Oh” Notation:
– given functions f(n) and g(n), we say that f(n)
is O(g(n) ) if and only if there are positive
constants c and n0 such that f(n)≤ c g(n) for n
≥ n0
Analysis of Algorithms 10
Example
For functions f(n) f(n) = 2n + 6
and g(n) (to the
right) there are
positive constants c
c g(n) =4n
and n0 such that:
f(n)≤c g(n) for n ≥ n0
conclusion: g(n) =n
2n+6 is O(n).
n
Analysis of Algorithms 11
Another Example
Analysis of Algorithms 12
Asymptotic Notation (cont.)
Analysis of Algorithms 13
Asymptotic Notation
(terminology)
• Special classes of algorithms:
logarithmic: O(log n)
linear: O(n)
quadratic: O(n2)
polynomial: O(nk), k ≥ 1
exponential: O(an), n > 1
Analysis of Algorithms 14
Asymptotic Analysis of The
Running Time
• Use the Big-Oh notation to express the number of primitive
operations executed as a function of the input size.
• For example, we say that the arrayMax algorithm runs in O(n)
time.
• Comparing the asymptotic running time
-an algorithm that runs in O(n) time is better than one that runs in O(n2) time
-similarly, O(log n) is better than O(n)
-hierarchy of functions: log n << n << n2 << n3 << 2n
• Caution! Beware of very large constant factors. An algorithm
running in time 1,000,000 n is still O(n) but might be less efficient
on your data set than one running in time 2n2, which is O(n2)
15
Example of Asymptotic
Analysis
An algorithm for computing prefix averages
Algorithm prefixAverages1(X):
Input: An n-element array X of numbers.
Output: An n -element array A of numbers such that A[i] is the average of elements
X[0], ... , X[i].
Let A be an array of n numbers.
for i 0 to n - 1 do
a0
for j 0 to i do
a a + X[j]
A[i] a/(i+ 1) 1 step i iterations n iterations
return array A with
• Analysis ... i=0,1,2...n-1
16
Another Example
• A better algorithm for computing prefix averages:
Algorithm prefixAverages2(X):
Input: An n-element array X of numbers.
Output: An n -element array A of numbers such that A[i] is the average of
elements X[0], ... , X[i].
Let A be an array of n numbers.
s 0
for i 0 to n do
s s + X[i]
A[i] s/(i+ 1)
return array A
• Analysis ...
Analysis of Algorithms 17
Math You Need to Review
Logarithms and Exponents (Appendix A, p.617)
• properties of logarithms:
logb(xy) = logbx + logby
logb (x/y) = logbx - logby
logbxa = alogbx
logba= logxa/logxb
• properties of exponentials:
a(b+c) = aba c
abc = (ab)c
ab /ac = a(b-c)
b = a logab
bc = a c*logab
Analysis of Algorithms 18
More Math to Review
Analysis of Algorithms 19