0% found this document useful (0 votes)
3 views

Algorithms Pseudocode Analysis

The document provides an overview of algorithm analysis, focusing on running time, average vs. worst-case scenarios, and measuring efficiency through asymptotic notation. It discusses the limitations of experimental studies and introduces a methodology for analyzing algorithms based on pseudo-code and primitive operations. Additionally, it covers key mathematical concepts necessary for understanding logarithms, exponents, and their properties in the context of algorithm analysis.

Uploaded by

HARSH VITHLANI
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
3 views

Algorithms Pseudocode Analysis

The document provides an overview of algorithm analysis, focusing on running time, average vs. worst-case scenarios, and measuring efficiency through asymptotic notation. It discusses the limitations of experimental studies and introduces a methodology for analyzing algorithms based on pseudo-code and primitive operations. Additionally, it covers key mathematical concepts necessary for understanding logarithms, exponents, and their properties in the context of algorithm analysis.

Uploaded by

HARSH VITHLANI
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 19

Analysis of Algorithms

• Running Time T(n)


• Pseudo-Code
n=4
• Analysis of
Algorithms
• Asymptotic Notation
• Asymptotic Analysis Input Algorithm Output
• Mathematical facts

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

• Experimental studies have several limitations:


– It is necessary to implement and test the algorithm in order to
determine its running time.
– Experiments can be done only on a limited set of inputs, and 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 should be used.

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

On the other hand…


n2 is not O(n) because there is
no c and n0 such that:
n2 ≤ cn for n ≥ n0

(As the graph to the right


illustrates, no matter how large
a c is chosen there is an n big
enough that n2>cn ) .

Analysis of Algorithms 12
Asymptotic Notation (cont.)

• Note: Even though it is correct to say “7n - 3 is O(n3)”, a


better statement is “7n - 3 is O(n)”, that is, one should make the
approximation as tight as possible

• Simple Rule: Drop lower order terms and constant


factors
7n-3 is O(n)
8n2log n + 5n2 + n is O(n2log n)

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

• “Relatives” of the Big-Oh


  (f(n)): Big Omega--asymptotic lower bound
  (f(n)): Big Theta--asymptotic tight bound

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
a0
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

• Floor: x = the largest integer ≤ x


• Ceiling: x = the smallest integer ≥ x
• Summations: (see Appendix A, p.619)
• Geometric progression: (see Appendix A, p.620)

Analysis of Algorithms 19

You might also like