ADT Stack. Inserting and deleting elements occurs at the top of Stack S. top. bottom. Stack S

Transcription

1 Stacks

2 Stacks & Queues A linear sequence, or list, is an ordered collection of elements: S = (s 1, s 2,..., s n ) Stacks and queues are finite linear sequences. A Stack is a LIFO (Last In First Out) list. A Queue is a FIFO (First In First Out) list.

3 ADT Stack top Inserting and deleting elements occurs at the top of Stack S bottom Stack S

4 Stack Operations mystack = new Stack( ); mystack.push(ape); mystack.push(eel); mystack top ape mystack top eel ape mystack top pet = mystack.pop(); boolean empty = mystack.isempty(); ape mystack top ape mystack top

5 Java NPSStack ADT /** * This interface defines the Stack ADT */ public interface NPSStack<E> { public void clear( ); public boolean isempty( ); public E peek( ) throws NPSStackEmptyException; public E pop( ) throws NPSStackEmptyException; public void push(e element); public int size( );

6 Defining the Stack ADT Array Implementation How should we represent an empty stack? ADT Stack does not overflow. How should we handle an array overflow? Linked List Implementation How should we represent an empty stack?

7 ArrayStack Implementation public class NPSArrayStack<E> implements NPSStack<E> { /** Default initial size of an array */ private static final int DEFAULT_SIZE = 25; /** An array to store the elements */ private E[] element; /** The number of elements in the stack. */ private int count; // /** Default constructor */ public NPSArrayStack( ) { this(default_size); /** Creates a stack with an initial capacity of size */ public NPSArrayStack( int size ) { element = (E[]) new Object[size]; count = 0;

8 ArrayStack Implementation /** Removes all elements from the stack. */ public void clear( ) { // // May or may not be desired (why?) // //for (int i = 0; i < count; i++ ) { // element[i] = null; // count = 0; /** Determines whether the stack is empty or not. */ public boolean isempty( ) { return (count == 0); /** Returns the number of elements in the stack */ public int size( ) { return count;

9 ArrayStack Implementation /** Returns the top-of-stack element without removing it */ public E peek( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { return element[count-1]; /** Removes the top-of-stack element. */ public E pop( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { return element[--count]; /** Adds an element to the stack. */ public void push(e element) { if (count == this.element.length) { expand( ); this.element[count++] = element;

10 ArrayStack Implementation /** Returns the top-of-stack element without removing it */ public E peek( ) throws NPSStackEmptyException { if (isempty( )) { throw new NPSStackEmptyException( ); else { return element[count-1]; /** Removes the top-of-stack element. */ public E pop( ) throws NPSStackEmptyException { E topelement = peek( ); count--; return topelement; /** Adds an element to the stack. */ public void push(e element) { if (count == this.element.length) { expand( ); this.element[count++] = element; This (private) method is left as an exercise.

11 Stack with a Singly Linked List We can implement a stack with a singly linked list The top element is stored at the first node of the list The space used is O(n) and each operation of the Stack ADT takes O(1) time Left as an exercise nodes t elements

12 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 Parenthesis matching HTML/XML Tag Matching Evaluating arithmetic expressions (more later) Indirect applications Auxiliary data structure for algorithms Component of other data structures

13 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 Local variables and return value Program counter, keeping track of the statement being executed When a method ends, its frame is popped from the stack and control is passed to the method on top of the stack Allows for recursion main() { int i = 5; foo(i); foo(int j) { int k; k = j+1; bar(k); bar(int m) { bar PC = 1 m = 6 foo PC = 3 j = 5 k = 6 main PC = 2 i = 5

14 Example: Parentheses Matching Each (, {, or [ must be paired with a matching ),, or [ correct: ( )(( )){([( )]) correct: ((( )(( )){([( )]) incorrect: )(( )){([( )]) incorrect: ({[ ]) incorrect: (

15 Parentheses Matching Algorithm Algorithm ParenMatch(X,n): Input: An array X of n tokens, each of which is either a grouping symbol, a variable, an arithmetic operator, or a number Output: true if and only if all the grouping symbols in X match Let S be an empty stack for i=0 to n-1 do if X[i] is an opening grouping symbol then S.push(X[i]) else if X[i] is a closing grouping symbol then if S.isEmpty() then return false {nothing to match with if S.pop() does not match the type of X[i] then return false {wrong type if S.isEmpty() then return true {every symbol matched else return false {some symbols were never matched

16 Example: HTML/XML Tag Matching For fully-correct HTML, each <name> should pair with a matching </name> <body> <center> <h1> The Little Boat </h1> </center> <p> The storm tossed the little boat like a cheap sneaker in an old washing machine. The three drunken fishermen were used to such treatment, of course, but not the tree salesman, who even as a stowaway now felt that he had overpaid for the voyage. </p> <ol> <li> Will the salesman die? </li> <li> What color is the boat? </li> <li> And what about Naomi? </li> </ol> </body> The Little Boat The storm tossed the little boat like a cheap sneaker in an old washing machine. The three drunken fishermen were used to such treatment, of course, but not the tree salesman, who even as a stowaway now felt that he had overpaid for the voyage. 1. Will the salesman die? 2. What color is the boat? 3. And what about Naomi?

17 Evaluating Arithmetic Expressions Write a program to evaluate arithmetic expressions such as Overall approach: sin 45 * ( ^ 2) Input an infix arithmetic expression Convert it into postfix format (use Stack here) Evaluate the postfix expression (use another Stack here) Output the result

18 Three Formats for Expressions Infix: operand operator operand Postfix: operand operand operator Prefix: operator operand operand + 4 5

19 Infix and Postfix Expressions Infix * 98 ((3-4 ) * 3 ) ^ (2 / 0.33) * 3-2 (4 + 5) * 3-2 Postfix * * / ^ * * 2 - Postfix expressions have no parentheses. Relative order of the operands are the same in infix and and postfix expressions

20 General Idea: Infix-to-Postfix Algorithm Scan the input for tokens (operators and operands). If the token is an operand, output it (or append it to the output string) If the token is an operator i, compare it with the top of stack operator s. If i has a lower priority than s, pop and output s. Repeat this comparison until you locate s that has a lower priority than i. Push i onto the stack. At the end of the input, pop and output everything on the stack (or append it to the output string, etc.)

21 Infix-to-Postfix Algorithm Example: * 3 There are five tokens: three operands and two operators. Operator * has a higher priority than +. Output is * + When the next token is * * * is stacked because its priority is higher than + * +

22 Sample Process Next Token: * * 3 5 * 3 * 3 3 Stack Content: + + * + * + Output: pop twice * +

23 Algorithm public static String convertinfixtopostfix(string infix) { StringBuffer postfix = new StringBuffer(); Stack<String> operatorstack = new Stack<String>(); StringTokenizer st = new StringTokenizer(infix); String nexttoken; Set<String> operators = opprecedence.keyset(); while (st.hasmoretokens()) { nexttoken = st.nexttoken(); if (!operators.contains(nexttoken)) { postfix.append(nexttoken + " "); else {// it is an Operator, another subclass of Token while (!operatorstack.isempty() && opprecedence.get(operatorstack.peek()) >= opprecedence.get(nexttoken)) postfix.append(operatorstack.pop() + " "); operatorstack.push(nexttoken); // Pop off remaining operators while (!operatorstack.isempty()) postfix.append(operatorstack.pop() + " "); return postfix.tostring();