Amortized Analysis

• This is from CLRS, but I want you to see this.
• Some algorithm/data structure performance is hard to determine in the manner we have been using.
• Assume a Stack with an additional operation: MultiPop
  • MultiPop takes a single integer parameter k.
  • It will pop the stack until k items have been removed or the stack is empty.
  • (I Will assume a member function with Empty() and Pop() methods.)

  • MULTI_POP(k)
    
     while not Empty() and k ≠ 0 do
         Pop()
         k ← k-1
    
    	

  • Normal Questions.
• So by it's self this is min(S.size(), k)
• So if we performed a series of n of these:

  • RANDOM_STACK_OP
    
     stack S
     for i ← 1 to n do
        op ← random(1..3)
        if op = 1 then
              S.Push(random Element)
        elif op = 2 then
              S.Pop()
        else 
              S.MultiPop(n)
    
        

  • Would it be O(n²) worst case?
  • Is this a tight bound?
• A better bound
  • While MultiPop is O(n), any series of operations on a stack, including MultiPop is O(n).
  • Our worst case is:
    • push n-1 items onto a stack (Line 5)
    • pop off all n-1 items in our last operation (line 9).
  • The performance of MultiPop is tied directly to the number of Push() and Pop() operations performed.
  • In fact, the worst case performance of RANDOM_STACK_OP is O(n)
    • The total time for this routine is O(n)
    • Taken over n operations, the total time for any member function (Push, Pop, MultiPop) is O(n)/n = O(1)
  • This is an amortized cost analysis.
• A binary counter.
  • Assume we have a k bit counter (Bits numbered 0 to k-1)
  • This will count from 0 to 2^k-1

  • INCREMENT(A)
    
     i ← 0
     while i < length[A] and A[i]=1 do
         A[i] ← 0
         i  ← i + 1
     if i < length[A] then
         A[i] ← 1;
    
    	 

  • Again a worst case analysis would give us O(k) for an increment.
  • Or counting n times would O(n*k)
  • But most of our increments (1/2 of them) are O(1)
  • 1/4 are O(2)
  • 1/8 are O(3)
  • So we have Σ_i=0^k-1⌊ n/2ⁱ ⌋ < n Σ_i=0^∞1/2ⁱ
  • But the second sum is 2n
  • So an individual increment is 2n/n = 2