stacks - kirkwood community college · 2019-09-19 · stacks . 2 . stack characteristics •...
TRANSCRIPT
![Page 1: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/1.jpg)
stacks 1
Stacks
The unorganized person’s data structure
![Page 2: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/2.jpg)
stacks 2
Stack characteristics
• Entries are ordered in terms of access -- both insertion and removal take place at same spot (top of stack)
• Specialized type of container class; defining characteristic is insertion/removal order
• LIFO = last in, first out; entries are removed in reverse order of insertion
![Page 3: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/3.jpg)
stacks 3
Stack operations
• Push -- insert item on stack • Pop -- remove item from stack • Peek -- examine, but don’t remove item • isEmpty – reports whether or not stack is
empty • size – returns # of items in stack • constructor
![Page 4: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/4.jpg)
stacks 4
Stack operations
• Important to know if stack is empty -- attempt to remove an item from an empty stack is an underflow error
• Depending on implementation, may be necessary to check if stack is full -- attempt to add item to a full stack is an overflow error
![Page 5: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/5.jpg)
Implementation of Stack ADT
• The Java API provides a generic stack implementation based on the Vector type
• We will use this implementation for programs that use stacks; but it is worth looking behind the scenes to see how a stack might be implemented if the API class didn’t exist
stacks 5
![Page 6: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/6.jpg)
stacks 6
Implementation of Stack ADT
• Stacks can be array based or linked list based
• Invariant for array implementation: – The number of items stored in the stack is
found in member variable manyItems – Items are stored in member variable data, an
array with the stack bottom at data[0] and the stack top at data[manyItems - 1]
![Page 7: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/7.jpg)
stacks 7
Stack class -- array version public class ArrayStack<E> implements Cloneable {
private Object[ ] data; private int manyItems;
final int INITIAL_CAPACITY = 10; public ArrayStack( ) { manyItems = 0; data = new Object[INITIAL_CAPACITY]; }
![Page 8: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/8.jpg)
stacks 8
Stack ADT continued
public ArrayStack(int initialCapacity) { if (initialCapacity < 0) throw new IllegalArgumentException ("initialCapacity too small: " + initialCapacity);
manyItems = 0; data = new Object[initialCapacity];
}
![Page 9: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/9.jpg)
Clone method
stacks 9
public ArrayStack<E> clone( ) { ArrayStack<E> answer; try { answer = (ArrayStack<E>) super.clone( ); } catch (CloneNotSupportedException e) { throw new RuntimeException ("This class does not implement Cloneable"); } answer.data = data.clone( ); return answer; }
![Page 10: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/10.jpg)
Resize method (ensureCapacity)
stacks 10
public void ensureCapacity(int minimumCapacity) { Object biggerArray[ ]; if (data.length < minimumCapacity) { biggerArray = new Object[minimumCapacity]; System.arraycopy(data, 0, biggerArray, 0, manyItems); data = biggerArray; } }
![Page 11: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/11.jpg)
Resize method (trimToSize)
stacks 11
public void trimToSize( ) { Object trimmedArray[ ]; if (data.length != manyItems) { trimmedArray = new Object[manyItems]; System.arraycopy(data, 0, trimmedArray, 0, manyItems); data = trimmedArray; } }
![Page 12: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/12.jpg)
Accessor methods
stacks 12
public int getCapacity( ) { return data.length; } public boolean isEmpty( ) { return (manyItems == 0); }
public int size( ) { return manyItems; }
![Page 13: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/13.jpg)
stacks 13
Pop method // Precondition: stack is not empty // Postcondition: top item is removed public Object pop( ) {
if (manyItems == 0) throw new EmptyStackException( ); return data[--manyItems];
}
![Page 14: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/14.jpg)
stacks 14
Peek function
// Precondition: stack is not empty // Postcondition: top item is revealed public Object peek( ) {
if (manyItems == 0) throw new EmptyStackException( ); return data[manyItems-1];
}
![Page 15: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/15.jpg)
stacks 15
Push function
// Precondition: stack is not full // Postcondition: an item is inserted on stack public void push(E item) {
if (manyItems == data.length) { ensureCapacity(manyItems*2 + 1); } data[manyItems] = item; manyItems++;
}
![Page 16: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/16.jpg)
stacks 16
Stack ADT as linked list
• Uses instance of Node class and methods from this class
• Stack can grow & shrink as needed to accommodate data -- no fixed size
![Page 17: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/17.jpg)
Invariant for LinkedStack
• The items in the stack are stored in a linked list, with the top of the stack stored at the head node, down to the bottom of the stack at the final node.
• The instance variable top is the head reference of the linked list of items.
stacks 17
![Page 18: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/18.jpg)
stacks 18
Class definition for new Stack
public class LinkedStack<E> implements Cloneable {
private Node<E> top;
public LinkedStack( ) { top = null; }
![Page 19: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/19.jpg)
stacks 19
Clone method
public LinkedStack<E> clone( ) { LinkedStack<E> answer; try { answer = (LinkedStack<E>) super.clone( ); } catch (CloneNotSupportedException e) { throw new RuntimeException ("This class does not implement Cloneable"); } answer.top = Node.listCopy(top); return answer;
}
![Page 20: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/20.jpg)
Accessor methods
stacks 20
public boolean isEmpty( ) { return (top == null); } public int size( ) { // The generic listLength method gets the type of E from top. return Node.listLength(top); }
![Page 21: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/21.jpg)
stacks 21
Push method
public void push(E item) {
top = new Node<E>(item, top); }
![Page 22: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/22.jpg)
stacks 22
Pop method
public E pop( ) { E answer; if (top == null) throw new EmptyStackException( ); answer = top.getData( ); top = top.getLink( ); return answer;
}
![Page 23: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/23.jpg)
stacks 23
Peek function
public E peek( ) { if (top == null) throw new EmptyStackException( ); return top.getData( );
}
![Page 24: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/24.jpg)
stacks 24
Stack application examples
• Compilers use stacks for a variety of purposes: – syntax analysis: matching brackets,
parentheses, etc. – activation records: structures associated with
functions, keeping track of local variables, return address, etc.
![Page 25: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/25.jpg)
stacks 25
Example application: balanced parentheses and brackets
• Pseudocode algorithm: – scan string left to right – if ‘(’ (or ‘[’ or ‘{’)is encountered, push on stack – if ‘)’ is encountered, and stack is not empty, pop
one ‘(‘ -- if stack is empty, expression is unbalanced
– if stack is empty when entire string has been scanned and analyzed, expression is balanced
![Page 26: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/26.jpg)
stacks 26
A method to test for balanced parentheses
public static boolean isBalanced(String expression) // Postcondition: A true return value indicates that the parentheses in the // given expression are balanced. Otherwise the return value is false. // Note that characters other than ( ) { } and [ ] are ignored. { // Meaningful names for characters final char LEFT_NORMAL = '('; final char RIGHT_NORMAL = ')'; final char LEFT_CURLY = '{'; final char RIGHT_CURLY = '}'; final char LEFT_SQUARE = '['; final char RIGHT_SQUARE = ']';
![Page 27: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/27.jpg)
Balanced paren method continued
stacks 27
Stack<Character> store = new Stack<Character>( ); // Stores parens int i; // An index into the string boolean failed = false; // Change to true for a mismatch for (i = 0; !failed && (i < expression.length( )); i++) { switch (expression.charAt(i)) { case LEFT_NORMAL: case LEFT_CURLY: case LEFT_SQUARE: store.push(expression.charAt(i)); break;
![Page 28: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/28.jpg)
Balanced parens continued
stacks 28
case RIGHT_NORMAL: if (store.isEmpty( ) || (store.pop( ) != LEFT_NORMAL)) failed = true; break; case RIGHT_CURLY: if (store.isEmpty( ) || (store.pop( ) != LEFT_CURLY)) failed = true; break; case RIGHT_SQUARE: if (store.isEmpty( ) || (store.pop( ) != LEFT_SQUARE)) failed = true; } // ends switch } // ends loop return (store.isEmpty( ) && !failed); } // ends method
![Page 29: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/29.jpg)
stacks 29
A stack-based calculator
• Input to program is a fully-parenthesized expression -- examples: ((5.3 * 1.2) / 3.1) (4 - 3)
• Two stacks are used -- one for operators, one for operands
• Right parenthesis is signal to pop the stacks and evaluate the expression
![Page 30: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/30.jpg)
stacks 30
Algorithm for expression evaluation
• Evaluate leftmost, innermost expression; continue evaluating, left to right – Read each part of expression – Push numbers on operand stack, operators on
operator stack – When right parenthesis is encountered, pop the
stacks, evaluate, and push result on operand stack
![Page 31: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/31.jpg)
Regular expressions and methods hasNext and findInLine
• Scanner class has methods that can be used to look ahead into an input stream
• The hasNext method can be used simply, to see if there is more data to be read in an input buffer; we used this technique in CS1 to read data to the end of the file
• The Stack calculator’s evaluate method uses the hasNext method, as well as another Scanner method, findInLine, to determine if the data to be read is of a particular kind
stacks 31
![Page 32: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/32.jpg)
Regular expressions and methods hasNext and findInLine
• These two methods can take as arguments a previously defined regular expression
• A regular expression indicates what a data item (e.g. a whole number, real number, or String) should consist of
• We can use an instance of the Pattern class to define a regular expression, as shown on the following slide
stacks 32
![Page 33: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/33.jpg)
Regular expressions and methods hasNext and findInLine
stacks 33
public static final Pattern CHARACTER = Pattern.compile("\\S.*?"); public static final Pattern UNSIGNED_DOUBLE = Pattern.compile("((\\d+\\.?\\d*)|(\\.\\d+))([Ee][-+]?\\d+)?.*?"); These patterns are used in the evaluate method to distinguish operators from operands
![Page 34: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/34.jpg)
Stack calculator: evaluate method • Precondition: The string is a fully parenthesized arithmetic
expression formed from non-negative numbers, parentheses, and the four operations // +, -, *, and /.
• Postcondition: The string has been evaluated and the value returned.
• Exceptions: – Can throw an NumberFormatException if the expression contains
characters other than digits, operations, parentheses and whitespace.
– Can throw IllegalArgumentException if the input line is an illegal expression, such as unbalanced parentheses or a division by zero.
stacks 34
![Page 35: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/35.jpg)
stacks 35
Code for stack calculator (evaluate method)
public static double evaluate(String s) { Scanner input = new Scanner(s);
Stack<Double> numbers = new Stack<Double>( ); Stack<Character> operations = new Stack<Character>( ); String next; char first;
![Page 36: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/36.jpg)
stacks 36
evaluate method continued
while (input.hasNext( )) { if (input.hasNext(UNSIGNED_DOUBLE)) { next = input.findInLine(UNSIGNED_DOUBLE); numbers.push(new Double(next)); } else { next = input.findInLine(CHARACTER); first = next.charAt(0);
![Page 37: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/37.jpg)
stacks 37
evaluate method continued switch (first) {
case '+': case '-': case '*': case '/': operations.push(first); break; case ')': evaluateStackTops(numbers, operations); break; case '(': break;
![Page 38: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/38.jpg)
stacks 38
evaluate method concluded
default : throw new IllegalArgumentException("Illegal character"); } // end switch
} // end else } // end while if (numbers.size( ) != 1)
throw new IllegalArgumentException ("Illegal input expression"); return numbers.pop( ); } // end method
![Page 39: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/39.jpg)
evaluateStackTops method
• Precondition: The top of the operations stack contains +, -, *, or /, and the numbers stack contains at least two numbers.
• Postcondition: The top two numbers have been popped from the numbers stack, and the top operation has been popped from the operations stack. The two numbers have been combined using the operation (with the second number popped as the left operand). The result of the operation has then been pushed back onto the numbers stack.
• Exceptions: Throws an IllegalArgumentException if the stacks are illegal or if the operation results in a division by zero.
stacks 39
![Page 40: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/40.jpg)
stacks 40
evaluateStackTops method
public static void evaluateStackTops(Stack<Double> nums, Stack<Character> ops) { double operand1, operand2;
if ((nums.size( ) < 2) || (ops.isEmpty( ))) throw new IllegalArgumentException("Illegal expression"); operand2 = nums.pop( ); operand1 = nums.pop( ); // continued on next slide
![Page 41: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/41.jpg)
stacks 41
evaluateStackTops method
switch (ops.pop( ) ){ case '+':
nums.push(operand1 + operand2); break; case '-':
nums.push(operand1 - operand2); break;
![Page 42: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/42.jpg)
stacks 42
evaluateStackTops method
case '*': numbers.push(operand1 * operand2);
break; case '/‘: numbers.push(operand1 / operand2);
break; default : throw new IllegalArgumentException ("Illegal operation"); } // end switch } // end method
![Page 43: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/43.jpg)
stacks2 43
The trouble with infix ...
• Rules for expression evaluation seem simple -- evaluate expression left to right, results of each sub-expression becoming operands to larger expression -- but …
• All operators are not created equal -- multiplication & division take precedence over addition & subtraction ...
![Page 44: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/44.jpg)
stacks2 44
The trouble with infix ...
• So it isn’t really all that simple -- we must first scan for higher-precedence operations, and evaluate these first -- and that’s not so easy to program -- so …
• In the calculator program, we rely on parentheses to tell us which operations to perform when -- hence the need for fully-parenthesized expression
![Page 45: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/45.jpg)
stacks2 45
Alternatives to infix -- prefix
• Prefix notation, a.k.a. Polish notation • Operator precedes operands
– infix expression: A + B – prefix expression: +AB
• Parentheses become unnecessary – infix expression: (A + B) * C – prefix expression: * + A B C
![Page 46: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/46.jpg)
stacks2 46
Converting from infix to prefix
• Write out operands in original order • Place operators in front of their operands • If there’s a compound expression, the prefix
expression may have two or more operators in a row
• If parentheses are not present, pay attention to precedence
![Page 47: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/47.jpg)
stacks2 47
A + B + C >>>>>> + + A B C A - B + C >>>>>> + - A B C A + (B - C) >>>>> + A - B C A * ((B + C) - D) / E >>> / * A - + B C D E A + B * C / D >>>> + A / * B C D A * B + C - D / E >>> - + * A B C / D E
Conversion examples
![Page 48: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/48.jpg)
stacks2 48
Prefix evaluation
• scan left to right until we find the first operator immediately followed by pair of operands
• evaluate expression, and replace the “used” operator & operands with the result
• continue until a single value remains
![Page 49: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/49.jpg)
stacks2 49
Prefix Example
+ * / 4 2 3 9 // original expression + * 2 3 9 // 4/2 evaluated + 6 9 // 2*3 evaluated 15 // 6+9 evaluated
![Page 50: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/50.jpg)
stacks2 50
Another example
* - + 4 3 5 / + 2 4 3 // original expression * - 7 5 / + 2 4 3 // 4+3 evaluated * 2 / + 2 4 3 // 7-5 evaluated * 2 / 6 3 // 2+4 evaluated * 2 2 // 6/3 evaluated 4 // 2*2 evaluated
![Page 51: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/51.jpg)
stacks2 51
Prefix summary
• Operands (but often not operators) same order as infix
• Expression designated unambiguously without parentheses
• Improvement on infix, but still not quite as simple to evaluate as one might wish -- have to deal with exceptions
![Page 52: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/52.jpg)
stacks2 52
Alternative II: Postfix
• Postfix is also known as reverse Polish notation -- widely used in HP calculators
• In postfix notation, operators appear after the operands they operate on
• As with prefix, operand order is maintained, and parentheses are not needed
• Postfix expression is not merely a reverse of the equivalent prefix expression
![Page 53: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/53.jpg)
stacks2 53
Postfix expression examples • Simple expression:
– Original Expression: A + B – Postfix Equivalent: A B +
• Compound expression with parentheses: – original: (A + B) * (C - D) – postfix: A B + C D - *
• Compound expression without parentheses: – original: A + B * C - D – postfix: A B C * + D -
![Page 54: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/54.jpg)
stacks2 54
Postfix expression evaluation
• Read expression left to right • When an operand is encountered, save it &
move on • When an operator is encountered, evaluate
expression, using operator & last 2 operands saved, saving the result
• When entire expression has been read, there should be one value left -- final result
![Page 55: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/55.jpg)
stacks2 55
Postfix evaluation using stack
• Postfix evaluation can easily be accomplished using a stack to keep track of operands
• As operands are encountered or created (through evaluation) they are pushed on stack
• When operator is encountered, pop two operands, evaluate, push result
![Page 56: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/56.jpg)
stacks2 56
Postfix calculator code
import java.util.*; import java.util.regex.*; public class PostfixCalculator { private String expression; private Stack<Double> nums; public static final Pattern CHARACTER = Pattern.compile("\\S.*?"); public static final Pattern UNSIGNED_DOUBLE = Pattern.compile("((\\d+\\.?\\d*)|(\\.\\d+))([Ee][-+]?\\d+)?.*?");
![Page 57: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/57.jpg)
Postfix calculator code
stacks2 57
public PostfixCalculator () { nums = new Stack<Double>(); expression = ""; }
![Page 58: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/58.jpg)
stacks2 58
Postfix calculator code
public void evalPostfix () { Scanner expression = new Scanner(this.expression); String next; do { if (expression.hasNext(UNSIGNED_DOUBLE)) { next = expression.findInLine(UNSIGNED_DOUBLE); nums.push(new Double(next)); }
![Page 59: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/59.jpg)
stacks2 59
Postfix calculator code
else { next = expression.findInLine(CHARACTER); calculate(next); } } while (expression.hasNext()); }
![Page 60: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/60.jpg)
stacks2 60
Postfix calculator code
public void calculate (String n) { if (nums.size() < 2) throw new IllegalArgumentException("Input expression: " + expression + " invalid"); double op2 = nums.pop(); double op1 = nums.pop(); char op = n.charAt(0);
![Page 61: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/61.jpg)
stacks2 61
Postfix calculator code
switch (op) { case '+': nums.push(op1 + op2); break; case '-': nums.push(op1 - op2); break; case '*': nums.push(op1 * op2); break; case '/': nums.push(op1 / op2); break; } }
![Page 62: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/62.jpg)
stacks2 62
Postfix calculator code
public double getResult() { if (nums.size() > 1 || nums.isEmpty()) throw new IllegalArgumentException("Input expression: " + expression + " invalid"); return (double)nums.pop(); } public void setExpression (String e) { expression = e; }
![Page 63: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/63.jpg)
Postfix calculator code
stacks2 63
public static void main (String [] args) { PostfixCalculator pc = new PostfixCalculator(); Scanner kb = new Scanner (System.in); String input; do { System.out.print ("Enter a postfix expression (or Q to quit: "); input = kb.nextLine(); if (input.equalsIgnoreCase("q")) System.out.println ("So long, and thanks for all the fish!");
![Page 64: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/64.jpg)
Postfix calculator code
stacks2 64
else { pc.setExpression(input); pc.evalPostfix(); System.out.println ("Your expression evaluates to: " + pc.getResult()); } } while (!input.equalsIgnoreCase("q")); } }
![Page 65: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/65.jpg)
stacks2 65
Translating infix to postfix
• Postfix expression evaluation is easiest type to program
• Next task is to take an infix expression and translate it into postfix for evaluation
• Some basic assumptions: – all operations are binary (no unary negative) – expressions are fully parenthesized
![Page 66: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/66.jpg)
stacks2 66
Translating infix to postfix
• General method: – move each operator to the right of its
corresponding right parenthesis – eliminate parentheses
• Example: (((A + B) * C) - (E * (F + G))) (((A B) + C) * (E (F G) +) * ) - A B+ C * E F G + * -
![Page 67: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/67.jpg)
stacks2 67
Pseudocode for translation program
Do { if (left parenthesis) read & push else if (operand) read & write to output string else if (operator) read & push else if (right parenthesis) read & discard pop operator & write to output string pop & discard left parenthesis } while (expression to read)
![Page 68: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/68.jpg)
stacks2 68
OK -- but what if expression isn’t fully parenthesized?
• We have to fall back on the rules for expression evaluation we know & love – do expression in parentheses first – do other operations in order of precedence -- in
case of tie, leftmost sub-expression wins • Example: A - ( B + C) * D - E • order: 3 1 2 4 • Postfix: A B C + D * - E -
![Page 69: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/69.jpg)
stacks2 69
Algorithm for expression conversion
Do if (left parenthesis) read & push else if (operand) read & write to file else if (arithmetic operator) // continued on next slide ...
![Page 70: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/70.jpg)
stacks2 70
Conversion algorithm continued
while (stack not empty && stack.peek( ) != ‘(‘ && op precedence lower than or same as
stack.peek( )) pop stack & write to file read op push op else // character should be ‘)’ // next slide ...
![Page 71: Stacks - Kirkwood Community College · 2019-09-19 · stacks . 2 . Stack characteristics • Entries are ordered in terms of access -- both insertion and removal take place at same](https://reader030.vdocuments.site/reader030/viewer/2022040720/5e2b2f3aed106e2fac6ffc9a/html5/thumbnails/71.jpg)
stacks2 71
Conversion algorithm continued read & discard right paren do pop stack & write to file while (stack.peek( ) != ‘(‘) pop & discard left paren while (expression to read) // ends outer loop while (stack not empty) pop & write to file