Date post: | 17-Nov-2014 |
Category: |
Documents |
Upload: | sagarvas82 |
View: | 166 times |
Download: | 1 times |
Lecture 23
Analysis review – amortization
Potential functions
Splay tree operations
Doubling array stacks
Array Based Stacks Operation Counting (Array-Doubling Implementation)
public void push(E obj) {if (t == S.length() - 1) {
A ← (E[]) new Object[S.length * 2]; for i ← 0 to S.length - 1 A[i] ← S[i];
S ← A;}++t;S[t] ← obj;
}
Analysis
• Worst case: a “push” into a stack with 2n items in it– Costs about 2n to copy all items to newly allocated
array
• But worst case happens rarely• In a sequence of k push operations, starting
from empty stack, at most log k doublings• Total cost of doublings = 1 + 2 + ..+ ~ 2k• So average cost was O(1)
Alternative analysis
• Idea: Amortization – you buy a new car for $20,000– You expect it to last 10 years
Amortization
• Approach 1: use the car, and in year 11, you have a $20,000 cost to replace it
• Approach 2: use the car, and in each year put $2000 in the bank– In the 11th year, spend the $20,000 you’ve
accumulated.
Analysis
• Approach 1: use the car, and in year 11, you have a $20,000 cost to replace it– Worst case cost: 20,000
• Approach 2: use the car, and in each year put $2000 in the bank– In the 11th year, spend the $20,000 you’ve
accumulated.– Worst case cost: $2000
Amortized analysis
• We can analyze the doubling array stack by saying “for each push operation, we’re going to pay whatever time it may take, plus enough time to do two more elementary operations.”
• Time taken for ordinary push: O(1) still!
Amortized analysis, continued
• Time taken for exceptional push onto a stack of size n:– n copies– plus an ordinary push.
• There must have been at least n/2 ordinary pushes since the last exceptional “push”
• We’ve therefore accumulated 2(n/2) extra operations
• Use these to pay for the “copy” operations• Amortized cost for exceptional push: also O(1)!
Potential functions
• Potential functions are a richer version of amortization.
• Idea: to each “state” s of the system (k items in a stack, some particular “shape” for a binary tree, …), we assign a number f(s). – Choosing f to make it useful is a dark art!– Typically f(s) represents “how bad is state s”?
• Example: in doubling-array stack, having n items in a stack of size n is pretty bad, because the next push will be expensive
• having ~n/2 items in such a stack is fine, because we just finished doubling.
Potential functions (cont.)
• We let c(s1 s2) denote the ordinary cost of changing from state s1 to state s2
• Define the “amortized cost” to be
h(s1 s2) = c(s1 s2) + f(s2) – f(s1)
• Do analysis in terms of amortized cost– …with a check at the end that the potential-
change wasn’t too great.
Amortized cost for a sequence of operations
h(s1 s2) = c(s1 s2) + f(s2) – f(s1)• What happens if we go from s1 to s4?
h(s1 s4) = h(s1 s2) + h(s2 s3) + h(s3 s4)
= h(s1 s2) + h(s2 s3) + c(s3 s4) + f(s4) – f(s3)
= h(s1 s2) + c(s2 s3) + f(s3) – f(s2) + c(s3 s4) + f(s4) – f(s3)
= h(s1 s2) + c(s2 s3) + c(s3 s4) + f(s4) – f(s3) + f(s3) – f(s2)
= h(s1 s2) + c(s2 s3) + c(s3 s4) + f(s4)– f(s2)
= c(s1 s2) + f(s2) – f(s1) + c(s2 s3) + c(s3 s4) + f(s4)– f(s2)
= c(s1 s2) + c(s2 s3) + c(s3 s4) + f(s4)– f(s2) + f(s2) – f(s1)
= c(s1 s2) + c(s2 s3) + c(s3 s4) + f(s4) – f(s1) = ordinary cost + change in potential from start to finish!
Amortized cost for sequence (cont’d)
h(s1 s4) =
c(s1 s2) + c(s2 s3) + c(s3 s4) +f(s4)– f(s1)
• This is just the ordinary cost plus the change in potential from the initial to final state!
• If this change in potential is small enough (again, choosing f requires cleverness!) then everything works out nicely.
We’ll return to potential functions for analyzing splay trees
Binary Search Tree Application
• Storing items that naturally occur in sequences– Stored in a way that makes access to kth item take
time log n, when there are n items total– Get fast access time only if tree is balanced– Want to do insertion/deletion operations, but maintain
balance• Sample application: video editing
– Tree node with key k stores location of the kth video-frame on disk
– Operations like “delete this section” or “move this clip to later” supported by BSTs, and are very fast
– access/insertion/deletion are fast using hashtable, too, but the bulk-move ops are not
Balanced BSTs
• Tons of kinds. – Red/black trees– 2-3-4 trees– skip lists (sort of)– treaps (trees with heap order on a random
value)– SPLAY TREES
Splay trees
• Binary search tree
• One main operation: splay node to root
• All other operations defined in terms of this one
Operations
• t is a splay tree, i is an item
• access(i, t): – do binary search for item i; if you find it, splay
to root. If not, splay the last non-null node encountered to the root. [in lecture, we changed this to “last node less than i”, but this was the wrong “fix” -- jfh]
Operations (cont.)
• join(t1, t2): combines two trees t1 and t2 into a single tree, assuming all items in t1 are less than all items in t2. – access largest item in t1; this makes it the
root, and its right subtree empty– insert t2 as the right subtree
Operations (cont.)
• split(i, t): split tree t into t1 and t2, with t1 containing all items less than or equal to i, and t2 containing all items greater than i. – splay(i, t); this moves i to the root (or perhaps
some node near to i, if i is not in the tree)– if i <= root, delete the edge from the root to its
right child; else delete the edge from root to left child; return the two resulting trees
Example: split 5
7
63
84
7
63
84
Search process. 5 not found; 6 was last node encountered
Example: split 5
7
63
84
Splay 6 to root5 is less than 6, so delete marked edge
6
3
74
8
6
3
74
8
Return the two resulting trees
Operations (cont.)
• insert(i, t): insert item i in tree t– first split(i, t) to get t1 and t2– build new tree with i at root, t1 and t2 as left
and right subtrees
• delete(i, t): delete item i from tree t– first access(i, t) to get i to root– let t1 and t2 be left and right subtrees of root– return join(t1, t2)
Splay operations
• while (x not root)– do appropriate operation to x
• Three cases– parent p(x) of x is the root of the tree (“zig”)– else:
• x and p(x) are both left or both right children (“zig zig”)
• x is left and p(x) is right child, or vice versa (“zig zag”
parent p(x) of x is the root of the tree (“zig”)else:
x and p(x) are both left or both right children (“zig zig”)x is left and p(x) is right child, or vice versa (“zig zag”
B
CD
E
F
G
H
A
ZIG operation
x
y x
y
A B
C A
B C
ZIG-ZIG
x
y
x
y
A B
C
A
B
C
D
z
D
z
ZIG-ZAG
x
y
x
y
A
B C
A B C
D
z
D
z
Operations in words
• zig: rotate edge joining x to p(x)
• zig-zig: rotate edge from p(x) to p(p(x)); then rotate edge from x to p(x)
• zig-zag: rotate edge from x to p(x); rotate edge from x to new p(x).
Rotation of an edge
x
yx
y
A B
CA
B C