1. Presentation by Marty Krogel
Chapter 17 Amortized Analysis
Presentation by Marty Krogel

2. Definition
Amortized analysis - A way of analyzing the time required to perform a series of operations on a data-structure by averaging the cost over all operations performed.

3. Chapter Outline 17.1 Aggregate analysis 17.2 The accounting method
17.3 The potential method
17.4 Dynamic tables (Applying the potential method)
Table expansion
Table expansion and contraction

4. 17.1 Aggregate analysis
The aggregate analysis spreads the total cost evenly amongst all operations performed. (Later analysis methods assign different costs to different operations.)
If the worst-case time of a series of operations is T(n), then the average cost, or amortized cost per operation is T(n)/n.

5. Stack example (On the whiteboard)

6. Incrementing binary counter example

7. Increment binary counter
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

8. Binary counter

9. Cost of INCREMENT

10. 17.2 The accounting method
For the accounting method, different operations are assigned different costs, called their amortized cost.
When an operation’s amortized cost is greater than it’s actual cost, the difference is assigned as credit to specific objects in a data structure and can be used later by operations who’s amortized cost is less than it’s actual cost.

11. Amortized cost notation
The sum of amortized cost of the n operations is greater than or equal to the sum of the actual cost of the n operations.

12. Stack example (On the whiteboard)

13. Incrementing binary counter example (On the whiteboard)

14. 17.3 The potential method
Instead of representing the prepaid work as credit, the potential method treats it as “potential energy” or just “potential” which is stored until it is needed later to pay for other operations.
Where Di represents the data structure after the ith operation, the potential function F maps the data structure Di to a real number F (Di). Thus, we are able to come up with an equation for the amortized cost of the ith operation.

15. Potential amortized cost

16. Stack example (On the whiteboard)

17. Incrementing binary counter example (On the whiteboard)

18. 17.4 Dynamic tables
As we all know, expanding an array involves creating a new array of a larger size and copying over all the elements in it, therefore it takes O(n) time.
What if I told you that, using amortized analysis, we can prove that a series of insertion operations on an array has a constant amortized cost, despite requiring a number of array expansions?

19. Table expansion TABLE-INSERT(T, x) if size[T] = 0
then allocate table[T] with 1 slot
size[T]  1
if num[T] = size[T]
then allocate new-table with 2 x size[T] slots
insert all items in table[T] into new-table
free table[T]
table[T]  new-table
size[T]  2 x size[T]
insert x into table[T]
num[T]  num[T] + 1

20. Table expansion

21. Table expansion and contraction
Since we double the table size when it is full, never dropping below a load factor of ½, one might think to contract the table when the load factor becomes ½. (This doesn’t work.)
Consider the case when n operations are performed on a table, where the first n/2 operations are insert (filling up the table). Then the following series is used for the next n/2 operations:
Ins,Del,Del,Ins,Ins,Del,Del,Ins,Ins…
This would result in n/2 expansions and contractions, each costing Q(n), for a total cost of Q(n2), which leaves us with an amortized cost of Q(n) per operation.

22. Potential method analysis
Solution: Don’t contract the table until the load factor gets below ¼, then reduce the table size by ½.
a(T) is the load factor and is equal to num[T] / size[T].

23. Case 1: TABLE-INSERT when ai-1 ³ ½.
ĉi = 3. (Calculated previously)
Case 2: TABLE-INSERT when ai-1 < ½.
ĉi = ci + Fi – Fi-1
= 1 + (sizei/2 – numi) – (sizei-1/2 – numi-1)
= 1 + (sizei/2 – numi) – (sizei/2 – numi –1)
= 0.
Case 3: TABLE-INSERT when ai-1 < ½, but ai ³ ½.
= 1 + (2 · numi –sizei) – (sizei-1/2 – numi-1)
= 1 + (2(numi-1+1) – sizei-1) – (sizei-1/2 – numi-1)
= 3 · numi-1 – (3/2) sizei-1+ 3
= 3ai-1sizei-1 – (3/2)sizei-1+ 3
= (3/2)sizei-1 – (3/2)sizei-1 + 3
= 3.

24. Case 4: TABLE-DELETE when ai-1 < ½ but no contraction.
ĉi = ci + Fi – Fi-1
= 1 + (sizei /2 – numi) – (sizei-1/2 – numi-1)
= 1 + (sizei /2 – numi) – (sizei /2 – (numi +1))
= 2.
Case 5: TABLE-DELETE when ai-1 < ½ with contraction.
= (numi + 1) + (sizei /2 – numi) – (sizei-1/2 – numi-1)
= (numi + 1) + ((numi + 1) – numi) – ((2 · numi + 2) – (numi + 1))
= 1.
Case 6: TABLE-DELETE when ai-1 ³ ½, but ai < ½.
= 1 + (sizei /2 – numi) – (2 · numi-1 – sizei-1)
= 1 + (3/2)sizei – (numi-1 – 1) – 2(numi-1 )
= (3/2)sizei – 3 numi
= (3/2)sizei – (3/2)sizei
= 0.
Case 7: TABLE-DELETE when ai, ai-1 ³ ½.
= 1 + (2 · numi – sizei) – (2 · numi-1 – sizei-1)
= 1 + 2(numi – (numi+1)) + (sizei – sizei)
= 1 – 2 + 0
= – 1