Stacks, Queues (cont d)

Transcription

1 Stacks, Queues (cont d) CSE 2011 Winter 2007 February 1, The Adapter Pattern Using methods of one class to implement methods of another class Example: using List to implement Stack and Queue 2 1

2 List Interface public interface List<AnyType> extends Collection<AnyType> { AnyType get( int idx ); AnyType set( int idx, AnyType newval ); void add( int idx, AnyType x ); void remove( int idx ); ListIterator<AnyType> listiterator( int pos ); int size() boolean isempty(); } 3 Implementing Stacks and Queues push (object) object pop() object top() int size() boolean isempty() enqueue(object) object dequeue() object front() int size() boolean isempty() 4 2

3 Pros and Cons Advantages Fast coding Simple code Disadvantages: may not be efficient Method calls We may not know the underlying data structure and implementation of List. 5 Applications of Stacks Balancing symbols Matching ( with ), { with }, [ with ], etc. Evaluating arithmetic expressions Converting infix expressions to postfix Evaluating postfix expressions Method/function calls 6 3

4 Balancing Symbols create a stack s; while (not end-of-file) { read c; if c is an opening symbol s.push(c); if c is a closing symbol if stack is empty report error; else { a = s.pop(); if a does not match c report error; } } if stack is not empty report error; 7 Postfix Expressions Computers evaluate arithmetic expressions using postfix expressions. Also called reverse Polish notation. Examples: a + b * c + ( d * e + f ) * g a b c 8 4

5 Evaluating Postfix Expressions Read in string, one item at a time. If the item is an operand, push on the stack. If the item is an operator, pop the stack twice and apply the operation to the popped values. Push the result on the stack. Continue until the string is completed and one value (the answer) remains on the stack. 9 Infix to Postfix Conversion Infix precedence: Parenthesis () Exponentiation ^ (Left to Right) Multiplication *, Division / (Left to Right) Addition +, Subtraction (Left to Right) To remember Please Excuse My Dear Aunt Sally 10 5

6 Infix to Postfix Conversion Assume the infix string is valid. Read in the infix string, one item at a time. If the item e is an operand, add to the postfix string output. If e is (, push it onto the stack. If e is ), pop the operators on the stack to the output until seeing a (, at which point pop ( and throw it away. If e is an operator and s is empty, push e onto stack s. 11 Infix to Postfix Conversion (cont d) A: if e is an operator and s is not empty, if e > top() then push e onto the stack if e = top() then pop the top to the output and push e onto the stack if e < top() then pop the top to the output and go to A. Note: NEVER pop ( though, until a matching ) When the infix string is empty, pop all the elements of the stack onto the postfix string to get the final result. 12 6

7 Method/Function Calls void main() { f(); } Be careful with recursive methods (expensive, or worse, infinite)! void f() { g(); h(); } void g() {} void h() {} 13 Method/Function Calls: Example top main() top f() main() top g() f() main() top h() f() main() 14 7

8 Extendable Arrays 15 Increment Strategies java.util.vector is similar to our List ADT It also uses extendable arrays capacityincrement determines how the array grows: capacityincrement = 0: capacityincrement = c > 0: array size doubles array adds c new cells A constructor: Vector (int initialcapacity, int capacityincrement) constructs an empty vector with the specified initial capacity and capacity increment. 16 8

9 Doubling the Capacity When add() is called and an overflow occurs (n = N): Allocate a new array T of capacity 2N Copy contents of the original array V into the first half of the new array T Set V = T Perform the insertion using new array V Note: when the number of elements in the list goes below a threshold (e.g., N/4), shrink the array by half the current size N of the array. 17 Time Analysis Push : inserting an element to be the last element of a list (or top of a stack) add(e) { Step 1: if overflow then extend the array; Step 2: push e to new array; } Proposition 1: Let S be a list implemented by means of an extendable array V as described before. The total time to perform a series of n push operations in S, starting from S being empty and V having size N = 1, is O(n). 18 9

10 Time Analysis (cont d) Step 2 takes O(n) (each push takes O(1)) Step 1: Allocate a new array T of capacity 2N Copy V[i] to T[i] for i = 0, 1,, N 1 Set V = T If the array is extended k times, then n = 2 k The total number of copies is: k 1 = 2 k 1 = n 1 = O(n) Step 1 + Step 2 = O(n) 19 Adding c Cells Proposition 2: If we create an initially empty java.util.vector object with a fixed positive capacityincrement value, then performing a series of n push operations on this vector takes Ω(n 2 ) time. Ω(n 2 ) means takes at least time n

11 Adding c Cells (cont d) Step 2 takes O(n) Step 1: Let a be the initial size of array V Let capacityincrement = c If the array is extended k times then n = a + ck The total number of copies is: (a) + (a+c) + (a+2c) + + (a+(k 1)c) = ak + c(1+2+ +(k 1)) = ak + ck(k 1)/2 = θ(k 2 ) = θ(n 2 ) We infer Ω(n 2 ) from θ(n 2 ) Which is the better increment strategy? 21 Sorting (again) 22 11

12 Quick Sort with Duplicate Elements Want to have A[p] pivot, for p < i A[p] pivot, for p > j pivot pivot When i < j i j Move i right, skipping over elements smaller than the pivot Move j left, skipping over elements greater than the pivot When both i and j have stopped A[i] pivot A[j] pivot A[i] and A[j] should now be swapped i j i j 23 Partitioning Strategy (cont d) When i and j have stopped and i is to the left of j (thus legal) Swap A[i] and A[j] The large element is pushed to the right and the small element is pushed to the left After swapping A[i] pivot A[j] pivot Repeat the process until i and j cross swap i j i j 24 12

13 Partitioning Strategy (cont d) When i and j have crossed swap A[i] and pivot Result: A[p] pivot, for p < i A[p] pivot, for p > i i Swap! i j j Break! j i 25 Partitioning Case 1: A[p] pivot, for p < i A[p] > pivot, for p > j Values same as pivot wind up in the 2 nd partition. Case 2: A[p] < pivot, for p < i A[p] pivot, for p > j Values same as pivot wind up in the 1 st partition. Case 3: A[p] pivot, for p < i A[p] pivot, for p > j Assume all values are same as pivot. All will be swapped. Inefficient??? Case 4: A[p] < pivot, for p < i A[p] > pivot, for p > j Both i and j run to their respective other ends. What happens next? 26 13

14 When to use which sorting algorithm? Large arrays: merge sort, quick sort. Small arrays: insertion sort, selection sort. Recursion is not cheap. Merge sort or quick sort? Cost of comparing elements Cost of moving/switching elements 27 Merge Sort or Quick Sort? Merge sort Lowest number of comparisons among popular algorithms Lots of data movements/copying (merging) Java Generic sort uses Comparator comparison is expensive. Moving is cheap (uses pointers rather than copies of objects). Quick sort More comparisons Fewer data movements C++ Copying large objects is expensive. Comparison is cheap (compiler does inline optimization). Java Used for primitive types (inexpensive comparisons) 28 14

15 What s left? Lower bound for sorting Iterators Will be discussed at the same as Trees