CHAPTER 2 Analysis of Algorithms

1
CHAPTER 2Analysis of Algorithms
Algorithm
Input
Output
An algorithm is a step-by-step procedure
for solving a problem in a finite amount of time.
2
Math you need to Review

• Series summations
• Logarithms and Exponents
• Proof techniques
• Basic probability

• properties of logarithms
• logb(xy) logbx logby
• logb (x/y) logbx - logby
• logbxa alogbx
• logba logxa/logxb
• properties of exponentials
• a(bc) aba c
• abc (ab)c
• ab /ac a(b-c)
• b a logab
• bc a clogab

3
Sum series-examples
4
(No Transcript)
5
(No Transcript)
6
Recurrence Relations
7
(No Transcript)
8
(No Transcript)
9
(No Transcript)
10
(No Transcript)
11
(No Transcript)
12
Assumptions for the computational model

• Basic computer with sequentially executed
  instructions
• Infinite memory
• Has standard operations addition,
  multiplication, comparison in 1 time unit unless
  stated otherwise
• Has fixed-size (32bits) integers such that
  no-fancy operations are allowed!!! eg.matrix
  inversion,

13
Running Time

• Most algorithms transform input objects into
  output objects.
• The running time of an algorithm typically grows
  with the input size.
• Average case time is often difficult to
  determine.
• We focus on the worst case running time.
• Easier to analyze
• Crucial to applications such as games, finance,
  image,robotics, AI, etc.

14
Experimental Studies

• Write a program implementing the algorithm
• Run the program with inputs of varying size and
  composition
• Assume a subprogram is written to get an accurate
  measure of the actual running time
• Plot the results

15
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

16
Theoretical Analysis

• Uses a high-level description of the algorithm
  instead of an implementation
• Characterizes running time as a function of the
  input size, n.
• Takes into account all possible inputs
• Allows us to evaluate the speed of an algorithm
  independent of the hardware/software environment

17
Pseudocode

• High-level description of an algorithm
• More structured than English prose
• Less detailed than a program
• Preferred notation for describing algorithms
• Hides program design issues

18
Pseudocode Details

• Control flow
• if then else
• while do
• repeat until
• for do
• Indentation replaces braces
• Method declaration
• Algorithm method (arg , arg)
• Input
• Output

• Method call
• var.method (arg , arg)
• Return value
• return expression
• Expressions
• Assignment(like ? in Java)
• Equality testing(like ?? in Java)
• n2 Superscripts and other mathematical formatting
  allowed

19
Important Functions

• Seven functions that often appear in algorithm
  analysis
• Constant ? 1
• Logarithmic ? log n
• Linear ? n
• N-Log-N ? n log n
• Quadratic ? n2
• Cubic ? n3
• Exponential ? 2n
• In a log-log chart, the slope of the line
  corresponds to the growth rate of the function

20
Primitive Operations

• Examples
• Evaluating an expression
• Assigning a value to a variable
• Indexing into an array
• Calling a method
• Returning from a method

• Basic computations performed by an algorithm
• Identifiable in pseudocode
• Largely independent from the programming language
• Exact definition not important
• Assumed to take a constant amount of time in the
  RAM model

21
Detailed Model 4 counting operations-1
The time require for the following operations are
all constants.
?fetch to fetch an integer operant from memory
?store to store an integer result in memory
? to add two integers
?- to subtract two integers
?x to multiply two integers
?/ to divide two integers
?lt to comparison of two integers
22
Detailed Model 4 counting operations-2
The time require for the following operations are
all constants.
?return to return from a method
?call to call a method
?store to pass an integer argument to a method
?. for the address calculation (not including the computation of the subscription)
?new to allocate a fixed amount of storage from the heap using new
23
Detailed Model 4 counting operations-3
Statement Time required
y x ?fetch ?store
y 1 ?fetch ?store
y y 1 2 ?fetch ? ?store
y 1 2 ?fetch ? ?store
y 2 ?fetch ? ?store
y 2 ?fetch ? ?store
24
Detailed Model... Example1Sum

• ...
• public static int sum(int n)
• int result 0
• for (int i 1 i lt n i)
• result i
• return result
• ...

Statement Time required
int result 0 ?fetch ?store
int i 1 ?fetch ?store
i lt n (2?fetch ?lt ) (n1)
i (2?fetch ? ?store) n
result i (2?fetch ? ?store) n
return result ?fetch ?return
25
Detailed Model... Example2 ()

• y a i
• 3?fetch ?. ?store
• operations
• fetch a (the base address of the array)
• fetch i (the index into the array)
• address calculation
• fetch array element ai
• store the result

26
Detailed Model...Example3 Horner ()

• public class Horner
• public static void main(String args)
• Horner h new Horner()
• int a 1, 3, 5
• System.out.println("a(1)" h.horner(a,
  a.length - 1, 1))
• System.out.println("a(2)" h.horner(a,
  a.length - 1, 2))
• int horner(int a, int n, int x)
• int result an
• for (int i n - 1 i gt 0 --i)
• result result x ai
• //System.out.println("i" i " result"
  result)
• return result

27
Detailed Model...Example-4 ()

• public class FindMaximum
• public static void main(String args)
• FindMaximum h new FindMaximum()
• int a 1, 3, 5
• System.out.println("max" h.findMaximum(a))
• int findMaximum(int a)
• int result a0
• for (int i 0 i lt a.length i)
• if (result lt ai)
• result ai
• System.out.println("i" i " result"
  result)
• return result

3?fetch ?. ?store ?fetch
?store (2?fetch ?lt) n (2?fetch ? ?store)
(n-1) (4?fetch ?. ?lt) (n-1) (3?fetch
?. ?store) ? ?fetch ?store
28
Simplified Model More Simplification

• All timing parameters are expressed in units of
  clock cycles. In effect, T1.
• The proportionality constant, k, for all timing
  parameters is assumed to be the same k1.

29
Simplified Model Example_FindMax

• public class FindMaximum
• public static void main(String args)
• FindMaximum h new FindMaximum()
• int a 1, 3, 5
• System.out.println("max" h.findMaximum(a))
• int findMaximum(int a)
• int result a0
• for (int i 0 i lt a.length i)
• if (result lt ai)
• result ai
• System.out.println("i" i " result"
  result)
• return result

1 2 3 4 5 6 7 8 9 10
detailed 2 3?fetch ?. ?store 3a ?fetch
?store 3b (2?fetch ?lt) n 3c (2?fetch ?
?store) (n-1) 4 (4?fetch ?. ?lt)
(n-1) 6 (3?fetch ?. ?store) ? 9 ?fetch
?store
simple 2 5 3a 2 3b (3)n 3c (4)(n-1) 4 (6)(n-1)
6 (5)? 9 2
30
Simplified Model gt Algorithm1Geometric Series
Sum

• public class GeometrikSeriesSum
• public static void main(String args)
• System.out.println("1, 4 "
  geometricSeriesSum(1, 4))
• System.out.println("2, 4 "
  geometricSeriesSum(2, 4))
• public static int geometricSeriesSum(int x, int
  n)
• int sum 0
• for (int i 0 i lt n i)
• int prod 1
• for (int j 0 j lt i j)
• prod x
• sum prod
• return sum

1 2 3 4 5 6 7 8 9 10 11 12
simple 1 2 2 3a 2 3b 3(n2) 3c 4(n1) 4 2(n1) 5a
2(n1) 5b 3 (i1) 5c 4 i 6 4
i 7 8 4(n1) 9 10 2 11 12 Total 11/2 n2 47/2 n
27
31
Simplified Model gt Algorithm_SumHornerGeometric
Series Sum
1 2 3 4 5 6 7

• public class GeometrikSeriesSumHorner
• public static void main(String args)
• System.out.println("1, 4 "
  geometricSeriesSum(1, 4))
• System.out.println("2, 4 "
  geometricSeriesSum(2, 4))
• public static int geometricSeriesSum(int x, int
  n)
• int sum 0
• for (int i 0 i lt n i)
• sum sum x 1
• return sum

• 2 2
• 3a 2
• 3b 3(n2)
• 3c 4(n1)
• 4 6(n1)
• 6 2
• Total 13 n 22

32
Simplified Model gt Algorithm_SumPower Geometric
Series Sum

• public class GeometrikSeriesSumPower
• public static void main(String args)
• System.out.println("1, 4 " powerA(1,
  4))
• System.out.println("1, 4 " powerB(1,
  4))
• System.out.println("2, 4 " powerA(2,
  4))
• System.out.println("2, 4 " powerB(2,
  4))
• ...
• public static int powerA(int x, int n)
• int result 1
• for (int i 1 i lt n i)
• result x
• return result
• public static int powerB(int x, int n)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1
7
powerB ? 1 n0 xn ? (x2)?n/2? 0ltn, n is
even ? x(x2)?n/2? 0ltn, n is odd
powerB 0ltn 0ltn n0 n even n
odd 10 3 3 3 11 2 - - 12 - 5 5 13 - 10T(?n/2?)
- 15 - - 12T(?n/2?) Total 5 18T(?n/2?) 20T(?n/
2?)
powerB ? 5 n0 xn ? 18T(?n/2?) 0ltn, n is
even ? 20T(?n/2?) 0ltn, n is odd
33
Simplified Model gt Calculation of PowerB
Geometric Series Sum ()

• Let n 2k for some kgt0.
• Since n is even, ?n/2? n/2 2k-1.
• For n 2k, T(2k) 18 T(2k-1).
• Using repeated substitution
• T(2k) 18 T(2k-1)
• 18 18 T(2k-2)
• 18 18 18 T(2k-3)
• 18j T(2k-j)
• Substitution stops when k j
• T(2k) 18k T(1)
• 18k 20 T(0)
• 18k 20 5
• 18k 25.
• n 2k then k log2 n

n is even
powerB xn ? 18T(?n/2?) 0ltn
34
Simplified Model gt Calculation of PowerB
Geometric Series Sum ()
Suppose n 2k1 for some kgt0. Since n is odd,
?n/2? ?(2k1)/2?
(2k2)/2 2k-1 For n 2k-1, T(2k-1) 20
T(2k-1-1), kgt1. Using repeated
substitution T(2k-1) 20 T(2k-1-1) 20 20
T(2k-2-1) 20 20 20 T(2k-3-1)
20j T(2k-j-1) Substitution stops when k
j T(2k-1) 20k T(20-1) 20k T(0) 20k
5. n 2k-1 then k log2 (n1) T(n) 20 log2
(n1) 5
n is odd
Therefore, powerB ? 5 n0 xn ? 18T(?n/2?)
0ltn, n is even ? 20T(?n/2?) 0ltn, n is
odd Average 19(?log2(n1)? 1) 18
35
Simplified Model gt Algorithm_SumPower Geometric
Series Sum

• public class GeometrikSeriesSumPower
• public static void main(String args)
• System.out.println(s 2, 4 "
  geometrikSeriesSumPower (2, 4))
• ...
• public static int geometrikSeriesSumPower (int
  x, int n)
• return powerB(x, n 1) 1 / (x - 1)
• public static int powerB(int x, int n)
• if (n 0)
• return 1
• else if (n 2 0) // n is even
• return powerB(x x, n / 2)
• else // n is odd
• return x powerB(x x, n / 2)

36
Comparison of 3 Algorithms
algorithm T(n) Sum 11/2 n2 47/2 n
27 Horner 13n 22 Power 19(?log2(n1)? 1) 18
sum
Horner
Power
37
Counting Primitive Operations for Pseudocodes

• By inspecting the pseudocode, we can determine
  the maximum number of primitive operations
  executed by an algorithm, as a function of the
  input size

• Algorithm arrayMax(A, n)
• operations
• currentMax ? A0 2
• for i ? 1 to n ? 1 do 2n
• if Ai ? currentMax then 2(n ? 1)
• currentMax ? Ai 2(n ? 1)
• increment counter i 2(n ? 1)
• return currentMax 1
• Total 8n ? 2

38
Estimating Running Time

• Algorithm arrayMax executes 8n ? 2 primitive
  operations in the worst case. Define
• a Time taken by the fastest primitive operation
• b Time taken by the slowest primitive
  operation
• Let T(n) be worst-case time of arrayMax. Then a
  (8n ? 2) ? T(n) ? b(8n ? 2)
• Hence, the running time T(n) is bounded by two
  linear functions

39
Asymptotic Algorithm Analysis

• The asymptotic analysis of an algorithm
  determines the running time in big-Oh notation
• To perform the asymptotic analysis
• 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
• Example
• We determine that algorithm arrayMax executes at
  most 8n ? 2 primitive operations
• We say that algorithm arrayMax runs in O(n)
  time
• Since constant factors and lower-order terms are
  eventually dropped anyhow, we can disregard them
  when counting primitive operations

40
Growth Rate of Running Time

• Changing the hardware/ software environment
• 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

41
Constant Factors

• The growth rate is not affected by
• constant factors or
• lower-order terms
• Examples
• 102n 105 is a linear function
• 105n2 108n is a quadratic function

42
Big-Oh Notation

• Given functions f(n) and g(n), we say that f(n)
  is O(g(n)) if there are positive constantsc and
  n0 such that
• f(n) ? cg(n) for n ? n0
• Example 2n 10 is O(n)
• 2n 10 ? cn
• (c ? 2) n ? 10
• n ? 10/(c ? 2)
• Pick c 3 and n0 10

43
Big-Oh Example

• Example the function n2 is not O(n)
• n2 ? cn
• n ? c
• The above inequality cannot be satisfied since c
  must be a constant

44
More Big-Oh Examples

• 7n-2

• 7n-2 is O(n)
• need c gt 0 and n0 ? 1 such that 7n-2 ? cn for n
  ? n0
• this is true for c 7 and n0 1

• 3n3 20n2 5

3n3 20n2 5 is O(n3) need c gt 0 and n0 ? 1
such that 3n3 20n2 5 ? cn3 for n ? n0 this
is true for c 4 and n0 21

• 3 log n 5

3 log n 5 is O(log n) need c gt 0 and n0 ? 1
such that 3 log n 5 ? clog n for n ? n0 this
is true for c 8 and n0 2
45
Big-Oh and Growth Rate

• The big-Oh notation gives an upper bound on the
  growth rate of a function
• The statement f(n) is O(g(n)) means that the
  growth rate of f(n) is no more than the growth
  rate of g(n)
• We can use the big-Oh notation to rank functions
  according to their growth rate

f(n) is O(g(n)) g(n) is O(f(n))
g(n) grows more Yes No
f(n) grows more No Yes
Same growth Yes Yes
46
More Example
47
Example
Stirlings approximation
48
Big-Oh Rules

• Theorem
• Consider polynomial where
  amgt0.Then f(n) O(nm). i.e.,
• Drop lower-order terms
• Drop constant factors

• Use the smallest possible class of functions
• Say 2n is O(n) instead of 2n is O(n2)
• Use the simplest expression of the class
• Say 3n 5 is O(n) instead of 3n 5 is O(3n)

49
Big-Oh Rules-2

• logk n O(n) for any constant k?Z

• f(n) O (f(n))
• c O(f(n)) O (f(n))
• O(f(n)) O(f(n)) O(f(n))
• O(O(f(n))) O(f(n))
• O(f(n)) O(g(n)) O(f(n) g(n))

50
Relatives of Big-Oh

• big-Omega
• f(n) is ?(g(n)) if there is a constant c gt 0
• and an integer constant n0 ? 1 such that
• f(n) ? cg(n) for n ? n0
• big-Theta
• f(n) is ?(g(n)) if there are constants c gt 0 and
  c gt 0 and an integer constant n0 ? 1 such that
  cg(n) ? f(n) ? cg(n) for n ? n0

51
Intuition for Asymptotic Notation

• Big-Oh
• f(n) is O(g(n)) if f(n) is asymptotically less
  than or equal to g(n)
• big-Omega
• f(n) is ?(g(n)) if f(n) is asymptotically greater
  than or equal to g(n)
• big-Theta
• f(n) is ?(g(n)) if f(n) is asymptotically equal
  to g(n)

52
Example Uses of the Relatives of Big-Oh

• 5n2 is ?(n2)

f(n) is ?(g(n)) if there is a constant c gt 0 and
an integer constant n0 ? 1 such that f(n) ?
cg(n) for n ? n0 let c 5 and n0 1

• 5n2 is O(n2)

f(n) is O(g(n)) if there is a constant c gt 0 and
an integer constant n0 ? 1 such that f(n) lt
cg(n) for n ? n0 let c 5 and n0 1

• 5n2 is ?(n2)

f(n) is ?(g(n)) if it is ?(n2) and O(n2). We have
already seen the former, for the latter recall
that f(n) is O(g(n)) if there is a constant c gt 0
and an integer constant n0 ? 1 such that f(n) lt
cg(n) for n ? n0 Let c 5 and n0 1
53
Comparison of Orders

• O(1) lt O(log n) lt O(n) lt O(n log n) lt O(n2) lt
  O(n3) lt O(2n)

54
Comparison of Orders

• O(1) lt O(log n) lt O(n) lt O(n log n) lt O(n2) lt
  O(n3) lt O(2n)

O(1)
O(log n)
O(n)
O(n log n)
O(n2)
O(n3)
O(2n)
55
O(n) Analysis of Running Time Example

• Worst-case running time if statement 5
  executes all the time
• Best-case running time if statement 5 never
  executes
• On-the-average running time if statement 5
  executes half of the time????

int findMaximum(int a) int result
a0 for (int i 1 i lt a.length i) if
(result lt ai) result ai return
result
1 2 3 4 5 6 7 8 9
56
Algorithm Complexity as a function of size n
Problem Input of size n Basic operation
Searching a list Sorting a list Multiplying two matrices Prime factorization Evaluating a polynomial Traversing a tree Towers of Hanoi lists with n elements lists with n elements two n-by-n matrices n-digit number polynomial of degrees n tree with n nodes n disks comparison comparison multiplication division multiplication accessing a node moving a disk

• A comparison-based algorithm for searching or
  sorting a list is
• based on
• making comparisons involving list elements
• then making decisions based on these comparisons.
• SOON U ll know all about these!!!

57
HWLA

• Solve Exercises in Chapter2 1, 7, 9 ,12, 25,
  29, 31

58
Computing Prefix Averages()

• We further illustrate asymptotic analysis with
  two algorithms for prefix averages
• The i-th prefix average of an array X is average
  of the first (i 1) elements of X
• Ai (X0 X1 Xi)/(i1)
• Computing the array A of prefix averages of
  another array X has applications to financial
  analysis such as ARMA, ARIMA, FARIMA, models.

59
Prefix Averages (Quadratic) ()

• The following algorithm computes prefix averages
  in quadratic time by applying the definition

Algorithm prefixAverages1(X, n) Input array X of
n integers Output array A of prefix averages of
X operations A ? new array of n integers
n for i ? 0 to n ? 1 do n s ? X0
n for j ? 1 to i do 1 2 (n ?
1) s ? s Xj 1 2 (n ? 1) Ai
? s / (i 1) n return A
1
60
Arithmetic Progression ()

• The running time of prefixAverages1 isO(1 2
  n)
• The sum of the first n integers is n(n 1) / 2
• There is a simple visual proof of this fact
• Thus, algorithm prefixAverages1 runs in O(n2)
  time

61
Prefix Averages (Linear) ()

• The following algorithm computes prefix averages
  in linear time by keeping a running sum

Algorithm prefixAverages2(X, n) Input array X of
n integers Output array A of prefix averages of
X operations A ? new array of n
integers n s ? 0 1 for i ? 0 to n ? 1
do n s ? s Xi n Ai ? s / (i 1)
n return A 1

• Algorithm prefixAverages2 runs in O(n) time

62
The Random Access Machine (RAM) Model ()

• A CPU
• A potentially unbounded bank of memory cells,
  each of which can hold an arbitrary number or
  character

• Memory cells are numbered and accessing any cell
  in memory takes unit time.

63
Quiz-1
64
Quiz-1 Solution
65
Quiz-2
66
Quiz-2 Solution