Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Stacks Outline and Reading The Stack ADT (§4.1) Applications of Stacks Array-based implementation (§4.1.2) Growable array-based stack Think of a spring-loaded plate dispenser week 2a 2 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations on the data Error conditions associated with operations Example: ADT modeling a simple stock trading system The data stored are buy/sell orders The operations supported are order buy(stock, shares, price) order sell(stock, shares, price) void cancel(order) Error conditions: Buy/sell a nonexistent stock Cancel a nonexistent order week 2a 3 The Stack ADT The Stack ADT stores arbitrary objects Insertions and deletions follow the last-in first-out scheme Main stack operations: push(object): inserts an element object pop(): removes and returns the last inserted element week 2a Auxiliary stack operations: object top(): returns the last inserted element without removing it integer size(): returns the number of elements stored boolean isEmpty(): indicates whether no elements are stored 4 Exceptions Attempting the execution of an operation of ADT may sometimes cause an error condition, called an exception Exceptions are said to be “thrown” by an operation that cannot be executed week 2a In the Stack ADT, operations pop and top cannot be performed if the stack is empty Attempting the execution of pop or top on an empty stack throws an EmptyStackException 5 Applications of Stacks Direct applications Page-visited history in a Web browser Undo sequence in a text editor Chain of method calls in the Java Virtual Machine Indirect applications Auxiliary data structure for algorithms Component of other data structures week 2a 6 Method Stack in the JVM The Java Virtual Machine (JVM) keeps track of the chain of active methods with a stack When a method is called, the JVM pushes on the stack a frame containing main() { int i = 5; foo(i); } foo(int j) { int k; Local variables and return value k = j+1; Program counter, keeping track of bar(k); the statement being executed } When a method ends, its frame is popped from the stack and bar(int m) { control is passed to the method … on top of the stack } week 2a bar PC = 1 m=6 foo PC = 3 j=5 k=6 main PC = 2 i=5 7 Array-based Stack A simple way of implementing the Stack ADT uses an array We add elements from left to right A variable keeps track of the index of the top element Algorithm size() return t + 1 Algorithm pop() if isEmpty() then throw EmptyStackException else tt1 return S[t + 1] … S 0 1 2 t week 2a 8 Array-based Stack (cont.) The array storing the stack elements may become full A push operation will then throw a FullStackException Algorithm push(o) if t = S.length 1 then throw FullStackException else tt+1 Limitation of the arrayS[t] o based implementation Not intrinsic to the Stack ADT … S 0 1 2 t week 2a 9 Performance and Limitations Performance Let n be the number of elements in the stack The space used is O(n) Each operation runs in time O(1) Limitations The maximum size of the stack must be defined a priori and cannot be changed Trying to push a new element into a full stack causes an implementation-specific exception week 2a 10 Computing Spans 7 We show how to use a stack 6 as an auxiliary data structure 5 in an algorithm 4 Given an an array X, the span 3 S[i] of X[i] is the maximum 2 number of consecutive elements X[j] immediately 1 preceding X[i] and such that 0 X[j] X[i] Spans have applications to financial analysis E.g., stock at 52-week high week 2a 0 X S 1 6 1 3 1 2 3 4 2 5 3 4 2 1 11 Quadratic Algorithm Algorithm spans1(X, n) Input array X of n integers Output array S of spans of X S new array of n integers for i 0 to n 1 do s1 while s i X[i s] X[i] ss+1 S[i] s return S # n n n 1 + 2 + …+ (n 1) 1 + 2 + …+ (n 1) n 1 Algorithm spans1 runs in O(n2) time week 2a 12 Computing Spans with a Stack We keep in a stack the indices of the elements visible when “looking back” We scan the array from left to right Let i be the current index We pop indices from the stack until we find index j such that X[i] X[j] We set S[i] i j We push i onto the stack week 2a 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 13 Linear Algorithm Each index of the array Is pushed into the stack exactly one Is popped from the stack at most once The statements in the while-loop are executed at most n times Algorithm spans2 runs in O(n) time Algorithm spans2(X, n) S new array of n integers A new empty stack for i 0 to n 1 do while (A.isEmpty() X[top()] X[i] ) do A.pop() if A.isEmpty() then S[i] i + 1 else S[i] i A.top() A.push(i) return S week 2a # n 1 n n n n n n n 1 14 Growable Array-based Stack In a push operation, when Algorithm push(o) the array is full, instead of if t = S.length 1 then throwing an exception, we A new array of can replace the array with size … a larger one for i 0 to t do A[i] S[i] How large should the new SA array be? incremental strategy: increase the size by a constant c doubling strategy: double the size week 2a tt+1 S[t] o 15 Comparison of the Strategies We compare the incremental strategy and the doubling strategy by analyzing the total time T(n) needed to perform a series of n push operations We assume that we start with an empty stack represented by an array of size 1 We call amortized time of a push operation the average time taken by a push over the series of operations, i.e., T(n)/n week 2a 16 Incremental Strategy Analysis We replace the array k = n/c times The total time T(n) of a series of n push operations is proportional to n + c + 2c + 3c + 4c + … + kc = n + c(1 + 2 + 3 + … + k) = n + ck(k + 1)/2 Since c is a constant, T(n) is O(n + k2), i.e., O(n2) The amortized time of a push operation is O(n) week 2a 17 Doubling Strategy Analysis We replace the array k = log2 n times The total time T(n) of a series of n push operations is proportional to n + 1 + 2 + 4 + 8 + …+ 2k = n + 2k + 1 1 = 2n 1 T(n) is O(n) The amortized time of a push operation is O(1) week 2a geometric series 2 4 1 1 8 18 Stack Interface in Java Java interface corresponding to our Stack ADT Requires the definition of class EmptyStackException Different from the built-in Java class java.util.Stack public interface Stack { public int size(); public boolean isEmpty(); public Object top() throws EmptyStackException; public void push(Object o); public Object pop() throws EmptyStackException; } week 2a 19 Array-based Stack in Java public class ArrayStack implements Stack { // holds the stack elements private Object S[ ]; // index to top element private int top = -1; // constructor public ArrayStack(int capacity) { S = new Object[capacity]); } public Object pop() throws EmptyStackException { if isEmpty() throw new EmptyStackException (“Empty stack: cannot pop”); Object temp = S[top]; // facilitates garbage collection S[top] = null; top = top – 1; return temp; } week 2a 20 Queues Outline and Reading The Queue ADT (§4.2) Implementation with a circular array (§4.2.2) Growable array-based queue Queue interface in Java week 2a 22 The Queue ADT The Queue ADT stores arbitrary objects Insertions and deletions follow the first-in first-out scheme Insertions are at the rear of the queue and removals are at the front of the queue Main queue operations: enqueue(object): inserts an element at the end of the queue object dequeue(): removes and returns the element at the front of the queue week 2a Auxiliary queue operations: object front(): returns the element at the front without removing it integer size(): returns the number of elements stored boolean isEmpty(): indicates whether no elements are stored Exceptions Attempting the execution of dequeue or front on an empty queue throws an EmptyQueueException 23 Applications of Queues Direct applications Waiting lists, bureaucracy Access to shared resources (e.g., printer) Multiprogramming Indirect applications Auxiliary data structure for algorithms Component of other data structures week 2a 24 Array-based Queue Use an array of size N in a circular fashion Two variables keep track of the front and rear f index of the front element r index immediately past the rear element Array location r is kept empty normal configuration Q 0 1 2 f r wrapped-around configuration Q 0 1 2 r f week 2a 25 Queue Operations We use the modulo operator (remainder of division) Algorithm size() return (N f + r) mod N Algorithm isEmpty() return (f = r) Q 0 1 2 f 0 1 2 r r Q f week 2a 26 Queue Operations (cont.) Operation enqueue throws an exception if the array is full This exception is implementationdependent Algorithm enqueue(o) if size() = N 1 then throw FullQueueException else Q[r] o r (r + 1) mod N Q 0 1 2 f 0 1 2 f r Q r week 2a 27 Queue Operations (cont.) Operation dequeue throws an exception if the queue is empty This exception is specified in the queue ADT Algorithm dequeue() if isEmpty() then throw EmptyQueueException else o Q[f] f (f + 1) mod N return o Q 0 1 2 f r Q 0 1 2 f r week 2a 28 Growable Array-based Queue In an enqueue operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one Similar to what we did for an array-based stack The enqueue operation has amortized running time O(n) with the incremental strategy O(1) with the doubling strategy week 2a 29 Queue Interface in Java Java interface corresponding to our Queue ADT Requires the definition of class EmptyQueueException No corresponding built-in Java class public interface Queue { public int size(); public boolean isEmpty(); public Object front() throws EmptyQueueException; public void enqueue(Object o); public Object dequeue() throws EmptyQueueException; } week 2a 30 Creativity: Describe in pseudo-code a linear-time algorithm for reversing a queue Q. To access the queue, you are only allowed to use the methods of queue ADT. week 2a 31 Answer: Algorithm reverseQueue(Queue Q) Create new stack S while (not Q.isEmpty()) do S.push(Q.dequeue()) while (not S.isEmpty()) do Q.enqueue(S.pop()) week 2a 32