CS4311 Design and Analysis of Algorithms. Lecture 14: Amortized Analysis I

Transcription

1 CS43 Design and Analysis of Algorithms Lecture 4: Amortized Analysis I

2 About this lecture Given a data structure, amortized analysis studies in a sequence of operations, the average time to perform an operation Introduce amortized cost of an operation Three Methods for the Same Purpose () Aggregate Method (2) Accounting Method (3) Potential Method This Lecture 2

3 Super Stack Your friend has created a super stack, which, apart from PUSH/POP, supports: SUPER-POP(k): pop top k items Suppose SUPER-POP never pops more items than current stack size The time for SUPER-POP is O(k) The time for PUSH/POP is O() 3

4 Super Stack Suppose we start with an empty stack, and we have performed n operations But we don t know the order Questions: Worst-case time of a SUPER-POP? Ans. O(n) time [why?] Total time of n operations in worst case? Ans. O(n 2 ) time [correct, but not tight] 4

5 Super Stack Though we don t know the order of the operations, we still know that: There are n PUSH/POP Time spent on PUSH/POP = O(n) # items popped by all SUPER-POP cannot exceed total # items ever pushed into stack Time spent on SUPER-POP = O(n) So, total time of n operations = O(n)!!! 5

6 Amortized Cost So far, there are no assumptions on n and the order of operations. Thus, we have: For any n and any sequence of n operations, worst-case total time = O(n) We can think of each operation performs in average O(n) / n = O() time We say amortized cost = O() per operation (or, each runs in amortized O() time) 6

7 Amortized Cost In general, we can say something like: OP runs in amortized O(x) time OP 2 runs in amortized O(y) time OP 3 runs in amortized O(z) time Meaning: For any sequence of operations with #OP = n, #OP 2 = n 2, #OP 3 = n 3, worst-case total time = O(n x + n 2 y + n 3 z) 7

8 Binary Counter Let us see another example of implementing a k-bit binary counter At the beginning, count is, and the counter will be like (assume k=5): which is the binary representation of the count 8

9 Binary Counter When the counter is incremented, the content will change Example: content of counter when: count = 5 cost = 2 count = 6 The cost of the increment is equal to the number of bits flipped 9

10 Special case: Binary Counter When all bits in the counter is, an increment resets all bits to count = MAX cost = k count = The cost of the corresponding increment is equal to k, the number of bits flipped

11 Binary Counter Suppose we have performed n increments Questions: Worst-case time of an increment? Ans. O(k) time Total time of n operations in worst case? Ans. O(nk) time [correct, but not tight]

12 Binary Counter Let us denote the bits in the counter by b, b, b 2,, b k-, starting from the right b 4 b 3 b 2 b b Observation: b i is flipped only once in every 2 i increments Precisely, b i is flipped at x th increment x is divisible by 2 i 2

13 Amortized Cost So, for n increments, the total cost is: i= to k b n / 2 i c i= to k ( n / 2 i ) 2n By dividing total cost with #increments, amortized cost of increment = O() 3

14 Aggregate Method The computation of amortized cost of an operation in super stack or binary counter follows similar steps:. Find total cost (thus, an aggregation ) 2. Divide total cost by #operations This method is called Aggregate Method 4

15 Remarks In amortized analysis, the amortized cost to perform an operation is computed by the average over all performed operations There is a different topic called averagecase analysis, which studies average performance over all inputs Both are useful, but they just study different things 5

16 Example: Average-Case Analysis Consider building a binary search tree for n numbers with random insertion order Final height varies on insertion order Suppose each of the n! possible insertion orders is equally likely to be chosen Then, we may be able to compute the average height of the tree average is over all insertion orders 6

17 Example: Average-Case Analysis In fact, we can show that average height = (log n) and very likely, height = (log n) So, we can say average search time = (log n) However, we cannot say amortized search time = (log n) why? 7