A Survey of Common Running Times Part I

• Linear:
  • Characteristic: Deal with every input item one time.
  • The computation on the individual item does not depend on the others.
  • Computing the max/min
    • Generally, store a current max/min
    • Then compare each item to this min/max
    • Update as necessary.

    •  
      
      Max(A)
         max = a0
         For i = 2 to n
            If  ai > max
               max = ai
            Endif
         Endfor 
       

    • Correct?
    • Can you prove it?
    • Best and worst case?
  • They point out that this is a reasonably common type of application
    • you might be observing a stream
    • You probably don't have to store the data.
  • Merging two lists.
    • $A = \{a_1, a_2, ... a_n\}, a_i \le a_j \forall ~ i \lt j $
    • $B = \{b_1, b_2, ... b_m\}, b_i \le b_j \forall ~ i \lt j $
    • For this case , $m = n $, but that doesn't have to be the case.
    • Form $C = \{c_1, c_2, ... c_{n+m}\}, c_i \le c_j \forall ~ i \lt j$
    • Brute force

      • MergeLists (A,B,C) 
        
         For i = 1 to A.size
             C[i] = A[i]
         Endfor
         For i = 1 to B.size
             C[i+m] = B[i]
         EndFor
         Sort(C); 
         

      • What does it do?
      • Is it right?
      • Performance?
    • A smarter algorithm
      • Think of merging two sorted stacks

      • MergeLists(A,B,C)
        
         aPos = 0
         bPos = 0
         index = 0
         While aPos < A.size and bPos < B.size
             If A[aPos] < B[bPos]
               C[index++]  = A[aPos++]
             Else
               C[index++]  = B[bPos++]
             Endif
         Endwhile
         While aPos < A.size
               C[index++]  = A[aPos++]
         Endwhile
         While bPos <  B.size
               C[index++]  = B[bPos++]
         Endwhile 

    • If we are not careful we might think this is more expensive.
    • But careful analysis tells us that each element of a or b will be assigned to C exactly one time.
    • Thus it is $O(2n) \in O(n)$
• $O(n\log n)$
  • We tend to get a $\log n$ factor any time we can cut the work in 1/2
  • Binary Search
  • Merge sort

    • MergeSort(A) 
      
       Divide A into two sub lists B and C each of size n/2 
       Sort B
       Sort C
       MergeLists(B,C,A)
       

    • How long would step 1 take?
    • Steps 2 and 3 will be addressed later.
    • How long will step 4 take?
    • This sort is $O(n \log n)$
  • Many algorithms require
    • sort then additional work
    • They are at least $O(n \log n)$
    • Interval scheduling

    • IntervalScheduling(tasks) 
            each task has a startTime and an endTime
      
       sort the tasks by finish time.
       current_time = 0
       position = 0
       While tasks still remain
           If task[position].starTime ≥ current_time
              schedule task[position]
              current_time = task[position].endTime
           EndIf
           position++
       EndWhile

    • Explain, Correct?, analize