Abstract Data Types Stack, Queue Amortized analysis

Queue Inject(x,Q) : Insert last element x into Q Pop(Q) : Delete the first element in Q Empty?(Q): Return yes if Q is empty Front(Q): Return the first element in Q Size(Q) Make-queue()

Implementation with lists head size=3 12 1 5 tail inject(4,Q)

Implementation with lists head size=3 12 1 5 4 tail inject(4,Q)

Implementation with lists head size=3 12 1 5 4 tail inject(4,Q) Complete the details by yourself

Double ended queue (deque) Push(x,D) : Insert x as the first in D Pop(D) : Delete the first element of D Inject(x,D): Insert x as the last in D Eject(D): Delete the last element of D Size(D) Empty?(D) Make-deque()

Implementation with doubly linked lists head tail size=2 13 5 x.next x.element x.prev x

Empty list size=0 We use two sentinels here to make the code simpler head tail size=0 We use two sentinels here to make the code simpler

Push size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next tail size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next (head.next).prev ← n head.next ← n n.prev← head size ← size + 1

4 size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next tail size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next (head.next).prev ← n head.next ← n n.prev← head size ← size + 1 push(4,D)

4 size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next tail size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next (head.next).prev ← n head.next ← n n.prev← head size ← size + 1 push(4,D)

4 size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next tail size=1 5 push(x,D): n = new node n.element ←x n.next ← head.next (head.next).prev ← n head.next ← n n.prev← head size ← size + 1 push(4,D)

4 size=2 5 push(x,D): n = new node n.element ←x n.next ← head.next tail size=2 5 push(x,D): n = new node n.element ←x n.next ← head.next (head.next).prev ← n head.next ← n n.prev← head size ← size + 1 push(4,D)

Implementations of the other operations are similar Try by yourself

Queue Inject(x,Q) : Insert last element x into Q Pop(Q) : Delete the first element in Q Empty?(Q): Return yes if Q is empty Front(Q): Return the first element in Q Size(Q) Make-queue()

Implementation with stacks 13 5 4 17 21 size=5 inject(x,Q): push(x,S2); size ← size + 1 inject(2,Q)

Implementation with stacks 13 5 4 17 21 2 size=5 inject(x,Q): push(x,S2); size ← size + 1 inject(2,Q)

Implementation with stacks 13 5 4 17 21 2 size=6 inject(x,Q): push(x,S2); size ← size + 1 inject(2,Q)

Pop S1 S2 13 5 4 17 21 2 size=6 pop(Q): if empty?(Q) error 5 4 17 21 2 size=6 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q)

Pop S2 S1 5 4 17 21 2 size=6 pop(Q): if empty?(Q) error 5 4 17 21 2 size=6 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q)

Pop S2 S1 5 4 17 21 2 size=5 pop(Q): if empty?(Q) error 5 4 17 21 2 size=5 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q) pop(D)

Pop S1 S2 2 5 4 17 21 size=5 pop(Q): if empty?(Q) error 5 4 17 21 size=5 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q) pop(D)

Pop S1 S2 21 2 5 4 17 size=5 pop(Q): if empty?(Q) error 5 4 17 size=5 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q) pop(D)

Pop S1 S2 17 21 2 5 4 size=5 pop(Q): if empty?(Q) error 5 4 size=5 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q) pop(D)

Pop S1 S2 4 17 21 2 5 size=5 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q) pop(D)

Pop S1 S2 5 4 17 21 2 size=5 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q) pop(D)

Pop S1 S2 4 17 21 2 size=4 pop(Q): if empty?(Q) error if empty?(S1) then move(S2, S1) pop( S1); size ← size -1 pop(Q) pop(D)

move(S2, S1) while not empty?(S2) do x ← pop(S2) push(x,S1)

Analysis O(n) worst case time per operation

Amortized Analysis How long it takes to perform m operations on the worst case ? O(nm) Really ?

Key Observation An expensive operation cannot occur too often !

The potential formalism The potential is in fact the bank

Define: a potential function  Amortized(op) = actual(op) + 

+ Amortized(op1) = actual(op1) + 1- 0 … Amortized(opn) = actual(opn) + n- (n-1) iAmortized(opi) = iactual(opi) + n- 0 iAmortized(opi)  iactual(opi) if n- 0  0

A better bound Consider Recall that: Amortized(op) = actual(op) + ΔΦ This is O(1) if a move does not occur Say we move S2: Then the actual time is |S2| + O(1) ΔΦ = -|S2| So the amortized time is O(1)

Conclusion If we start with an empty queue and perform m operations then its takes O(m) time

Back to deques Alternative implementation using stacks

Implementation with stacks 13 5 4 17 21 size=5 push(x,D): push(x,S1) push(2,D)

Implementation with stacks 2 13 5 4 17 21 size=6 push(x,D): push(x,S1) push(2,D)

Pop S1 S2 2 13 5 4 17 21 size=6 pop(D): if empty?(D) error 5 4 17 21 size=6 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D)

Pop S1 S2 13 5 4 17 21 size=5 pop(D): if empty?(D) error 5 4 17 21 size=5 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D) pop(D)

Pop S2 S1 5 4 17 21 size=4 pop(D): if empty?(D) error 5 4 17 21 size=4 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D) pop(D)

Pop S2 S1 5 4 17 21 size=4 pop(D): if empty?(D) error 5 4 17 21 size=4 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D)

Pop S2 S1 5 4 17 21 size=4 pop(D): if empty?(D) error 5 4 17 21 size=4 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D)

Pop S2 S1 5 4 17 21 size=4 pop(D): if empty?(D) error 5 4 S2 17 21 size=4 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D)

Pop S1 S2 4 17 21 size=4 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D)

Pop S1 S2 4 17 21 size=3 pop(D): if empty?(D) error if empty?(S1) then split(S2, S1) pop( S1) pop(D)

Split S1 S2 5 4 17 21 S3

Split S1 S2 5 4 17 S3 21

Split S1 S2 5 4 S3 17 21

Split S1 S2 4 5 S3 17 21

Split S1 S2 5 4 S3 17 21

Split S1 17 S2 5 4 S3 21

Split S1 S2 5 4 17 21 S3

split(S2, S1) S3 ← make-stack() d ← size(S2) while (i ≤ ⌊d/2⌋) do x ← pop(S2) push(x,S3) i ← i+1 while (i ≤ ⌈d/2⌉) do x ← pop(S2) push(x,S1) i ← i+1 x ← pop(S3) push(x,S2) i ← i+1

Analysis O(n) worst case time per operation

Amortized Analysis How long it takes to perform m operations on the worst case ? O(nm) Really ?

Key Observation An expensive operation cannot occur too often !

A better bound Consider Recall that: Amortized(op) = actual(op) + ΔΦ This is O(1) if no splitting occurs Say we split S1: Then the actual time is |S1| + O(1) ΔΦ = -|S1| So the amortized time is O(1)

Conclusion If we start with an empty deque and perform m operations then its takes O(m) time