Analysis Tools, Chapter 3

Running Time and Pseudo Code

• We have all encounterd O(n) notation
• What is this?
• Why do we go to this level of abstraction?
• What is wrong with just running time?
  • Unix system call time
  • Returns the current clock time (in seconds)
  • start = time(NULL);
• So to decide how an algorithm performs
  • Code the solution
  • Run it a bunch of times with different sizes of input
  • Analize the results (graph?)
  • Consider this code
  • On my machines at home I have the following results.
    • Celeron (400MHz)
    • 
    • But if I ran the optimizer I have
    • 
    • Or on the 2.66GHz Xeon
    • 
    • In each case, the plot is time vs number of elements
    • Where number of elements is n*10⁴
    • Notice, the shape of the curve remains the same but the point of reference change (200 seconds to 31 seconds)
    • When I studied these algorithms back in the early '80s these runs would have taken hours or even days.
• Direct timing is not satisfactory for a number of reasons
  • it does not have lasting meaning (do you care if it runs in 10 seconds on a 1985 vax?)
  • It depends on the hardware (cache size will greatly influence the performance of a sort, if it fits in cache, it will run much faster than if it doesn't.
  • It depends on the software as well. Notice the optimized code above is much faster then the code that is not.
  • It also depends on the implementation, bad code labels the algorithm as slow.
  • And you have to implement the code.
    • Assume you are comparing four different complex algorithms.
• Goodrich gives us a list of criteria for a methodology for analyzing an algorithm
  • It should take into account all possible inputs
  • Allow the analysis to be independant of the environment.
  • Can be done on a high level description of the algorithm.
• Pseudo Code
  • A mixture of english, pictures and code
  • You use whatever you need to when describing an algorithm.
  • Be as generic as you can yet still express the idea
    • Don't omit things that are overly complex as simple
    • Don't hide the essence of the algorithm with extra details.
  • Often code is double or triple the size of the algorithm.
  • Consider sort4 (in the code above)

    sort4(array, start end);
        if (start < end) {
            split(array, start, end, pivot)
            sort4(array, start, pivot-1);
            sort4(array, pivot+1, end);
        }
    
    split(array, start, end pivot)
       pick a pivot
       move everything larger than the pivot to the top of the array
       move everything smaller than the pivot to the bottom of the array
       put the pivot between the two
    	

  • He gives an explaination of the pseudo code he will use on page 112. You should look this over.