CSE Data Structures and Algorithms... In Java! Stacks. CSE2100 DS & Algorithms 1

Transcription

1 CSE 2100 Data Structures and Algorithms... In Java Stacks 1

2 What is Stack A stack is a collection of objects that are inserted and removed according to the last-in, first-out (LIFO) principle. Internet web browsers store the addresses of recently visited website on a stack, which allows the user to "pop" back to previously visited sites using the "back" button Text editors usually provide an "undo" mechanism that cancels recent editing operations and reverts to former states of a document. This undo operation can be accomplished by keeping text changes in a stack 2

3 The Stack ADT The Stack ADT stores arbitrary objects Insertions and deletions follow the LIFO scheme Main stack operations: push(object): inserts an element object pop(): removes and returns the last inserted element 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 3

4 Java Stack Interface public interface Stack<E> { int size(); boolean isempty(); void push(e e); E top(); E pop(); An interface is an empty shell, there are only the signatures of the methods, which implies that the methods do not have a body. The interface can't do anything. It's just a pattern. 4

5 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 The array storing the stack elements may become full S t 5

6 ArrayStack public class ArrayStack<E> implements Stack<E> { /** Default array capacity. */ public static final int CAPACITY=1000; // default array capacity /** Generic array used for storage of stack elements. */ private E[] data; // generic array used for storage /** Index of the top element of the stack in the array. */ private int t = -1; // index of the top element in stack /** Constructs an empty stack using the default array capacity. */ public ArrayStack() { this(capacity); // constructs stack with default capacity /** * Constructs and empty stack with the given array capacity. capacity length of the underlying array public ArrayStack(int capacity) { // constructs stack with given capacity data = (E[]) new Object[capacity]; // safe cast; compiler may give warning 6

7 ArrayStack public int size() { return (t + 1); public boolean isempty() { return (t == -1); public void push(e e) throws IllegalStateException { if (size() == data.length) throw new IllegalStateException("Stack is full"); data[++t] = e; // increment t before storing new item public E top() { if (isempty()) return null; return data[t]; public E pop() { if (isempty()) return null; E answer = data[t]; data[t] = null; t--; return answer; // dereference to help garbage collection 7

8 Stack using 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 nodes t elements 8

9 LinkedStack public class LinkedStack<E> implements Stack<E> { /** The primary storage for elements of the stack */ private SinglyLinkedList<E> list = new SinglyLinkedList<>(); // an empty list /** Constructs an initially empty stack. */ public LinkedStack() { // new stack relies on the initially empty list public int size() { return list.size(); public boolean isempty() { return list.isempty(); public void push(e element) { list.addfirst(element); public E top() { return list.first(); public E pop() { return list.removefirst(); 9

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

11 Parentheses Matching 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 11

12 Parentheses Matching /** Tests if delimiters in the given expression are properly matched. */ public static boolean ismatched(string expression) { final String opening = "({["; // opening delimiters final String closing = ")]"; // respective closing delimiters Stack<Character> buffer = new LinkedStack<>(); for (char c : expression.tochararray()) { if (opening.indexof(c) = -1) // this is a left delimiter buffer.push(c); else if (closing.indexof(c) = -1) { // this is a right delimiter if (buffer.isempty()) // nothing to match with return false; if (closing.indexof(c) = opening.indexof(buffer.pop())) return false; // mismatched delimiter return buffer.isempty(); // were all opening delimiters matched? 12

13 HTML 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? 13

14 HTML Tag Matching /** Tests if every opening tag has a matching closing tag in HTML string. */ public static boolean ishtmlmatched(string html) { Stack<String> buffer = new LinkedStack<>(); int j = html.indexof('<'); // find first '<' character (if any) while (j = -1) { int k = html.indexof('>', j+1); // find next '>' character if (k == -1) return false; // invalid tag String tag = html.substring(j+1, k); // strip away < > if (tag.startswith("/")) // this is an opening tag buffer.push(tag); else { // this is a closing tag if (buffer.isempty()) return false; // no tag to match if (tag.substring(1).equals(buffer.pop())) return false; // mismatched tag j = html.indexof('<', k+1); // find next '<' character (if any) return buffer.isempty(); // were all opening tags matched? 14

15 Arithmetic Evaluation To evaluate an expression, such as 1+2*3+4, you need two stacks: one for operands (numbers), the other for operators: going left to right, If you see a number, push it on the number stack If you see an operator, While the top of the operator stack holds an operator of equal or higher precedence: pop the old operator pop the top two values from the number stack and apply the old operator to them push the result on the number stack push the new operator on the operator stack At the end, perform any remaining operations 15

16 Example: 1+2*3+4 1 : push 1 on number stack + : push + on op stack 2 : push 2 on number stack * : because * has higher precedence than +, push * onto op stack 3 : push 3 onto number stack + : because + has lower precedence than *: pop 3, 2, and * compute 2*3=6, and push 6 onto number stack push + onto op stack 4 : push 4 onto number stack end : pop 4, 6 and +, compute 6+4=10, push 10; pop 10, 1, and +, compute 1+10=11, push (at the top of the stack) is the answer 16

17 Example: 1+2* * *