Introduction to Algorithm Analysis

• Read chapter 2.
• In this chapter we begin to discuss how to analyze algorithms.
• This is a difficult task
  • Just like factoring, all of your analysis has been of "easy" algorithms
  • It becomes more of a challenge when we start working with recursive algorithms.
• We concern ourselves with both time and space complexity.
• We are also often concerned about best, worst, and average complexity.
• Input size
  • Just exactly what is the n we are talking about/
  • This depends on the problem and what the input is.
  • It is always related to the input.
    • If there is no input, then the program should run the same every time.
  • So we need some measure which we can use to predict how long the program will run.
  • For starting, it is obvious, the size of the array to be sorted.
  • For evaluation of a polynomial, p(x) = a_nxⁿ+ a_n-1x^n-1 + ... + a₁x+a₀, it will be the degree of the polynomial.
  • What would you expect for matrix multiplication?

    	     | 1 3 2|
    | 1 2 3 4|   | 9 4 2|  | 1x1+2x9+3x7+4x5  1x3+2x4+3x4+4x8 1x2+2x2+3x1+4x2|
    | 2 4 1 3| x | 7 4 1|  | ...                                    ...      |
    | 2 7 5 3|   | 5 8 2|  | ...                              2x2+7x2+5x1+3x2|
    	 

  • Sometimes it can involve two different input quantities
    • In string matching, we search for a pattern in a text.

    • BRUTE_MATCH(T,P)
      
       L ← []
       fori ← 0 to  T.size()-P.size() do
           S ← T.substring(i, P.size());
           if (S = P) then
                 L.append(i)
       return L
      
      	      

    • Both the size of the pattern and the size of the text determine how long this algorithm will take.
    • This is often the case in graph algorithms, where G={V,E}
      • V is the set of vertexes
      • E is the set of edges.
      • We frequently use |V| and |E| to compute complexity
  • The GCD problem presents a special problem.
    • The input is always size 2?
    • But do bigger numbers cause the algorithm to take more time?
    • Frequently we measure the size of the numbers
    • n = ⌊ log₂(n) ⌋ + 1
    • Just to remind us , ⌊ n ⌋ is the largest integer less than or equal to n.
    • And ⌈ n ⌉ is the smallest integer greater than or equal to n.
  • We need to be careful that we state the value of "n" when we are doing a performance analysis.
    • When it is not a "normal" choice
    • It is not an "obvious" choice
    • Your instructor asks for it.
• Measuring Performance
  • We next need to decide on a measure of performance
  • How about seconds, or some unit in terms of wall clock time?
    • How would this be good?
    • How would this be bad?
  • How about performance on some machine?
    • Vax 11/780 (VaxMark) A 1 mips machine!
    • Take a gander at this Chart
  • So what we decide to do is count instructions.
    • But which instruction?
    • From an instruction set?
    • Which one? Back to tied to a machine.
    • So we assume a "generic" instruction set
    • But something that is doable, no "gnpn" instruction!
      • (Generate Next Prime Number)
  • But what instructions do we count then?
    • Different architectures have different instructions.
    • So code on one machine may require far more code than on another machine.
  • So we decide not to count ALL instructions.
  • But select a central instruction to the algorithm and count the number of times it is executed.
    • Like the selection of the measure of input size (n), this is sometimes easy and sometimes difficult.
    • What is it in selection sort?
    • How about Permutation Sort?
    • The GCD algorithms?
  • It is important to state the basic operation you are counting
    • When it is not a "normal" choice
    • It is not an "obvious" choice
    • Your instructor asks for it.
• In the end, we want to count our basic operation in terms of the input size n.