1 / 49

Stacks

Stacks. Chapter 5. Chapter Objectives. To learn about the stack data type and how to use its four methods: push , pop , peek , and empty To understand how Java implements a stack To learn how to implement a stack using an underlying array or a linked list

saad
Download Presentation

Stacks

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Stacks Chapter 5

  2. Chapter Objectives • To learn about the stack data type and how to use its four methods: push, pop, peek, and empty • To understand how Java implements a stack • To learn how to implement a stack using an underlying array or a linked list • To see how to use a stack to perform various applications, including finding palindromes, testing for balanced (properly nested) parentheses, and evaluating arithmetic expressions Chapter 5: Stacks

  3. Stack • Dinner plates at a cafeteria • Spring-loaded “stack” of plates • “Push” a new plate onto the stack • “Pop” an existing plate off of the stack • Only the top plate is accessible • “Last-In, First-Out”, or LIFO Chapter 5: Stacks

  4. Stack • Pez dispenser also uses a stack • Only the top Pez candy can be accessed • Can only extract one item at a time • “Push” candy onto stack • “Pop” candy off of stack • Only the top candy is accessible, LIFO, etc. Chapter 5: Stacks

  5. Stack • Stack might seem to be too restrictive • LIFO • Only one element accessible • Only operations are push, pop, peek, empty • However, stacks are extremely useful in CS • Simple and useful • For example, stacks used when executing programs • Used like “scratch paper” to keep track of info Chapter 5: Stacks

  6. Specification of the Stack Abstract Data Type • Only the top element of a stack is visible, therefore the number of operations performed by a stack are few • The only operations available are • Inspect the top element (peek) • Retrieve (and remove) the top element (pop) • Put a new element on the stack (push) • Test for an empty stack (empty) Chapter 5: Stacks

  7. Specification of the Stack Abstract Data Type (continued) Chapter 5: Stacks

  8. StackInt<E> Interface /** Stack is a LIFO data structure */ publicinterface StackInt < E > { /** Pushes an item onto the top of the stack and returns the item pushed. */ E push(E obj); /** Returns the object at the top of the stack without removing it. */ E peek(); /** Returns the object at the top of the stack and removes it. */ E pop(); /** Returns true if the stack is empty; otherwise, returns false.*/ boolean empty();} Chapter 5: Stacks

  9. Alice Bob Trudy Alice Bob Stack Example • Suppose we have a stack called names • And we execute names.pop(); • What is the return value? • “Trudy” and the stack is Chapter 5: Stacks

  10. Alice Bob Alice Bob Charlie Stack Example • We now have the stack • And we execute names.push(“Charlie”); • What is the return value? • “Charlie” and stack is Chapter 5: Stacks

  11. Alice Bob Charlie Alice Bob Charlie Stack Example • We now have the stack • And we execute names.peek(); • What is the return value? • “Charlie” and stack is Chapter 5: Stacks

  12. Alice Bob Charlie Alice Bob Charlie Stack Example • We now have the stack • And we execute names.empty(); • What is return value? • Returns false and stack is Chapter 5: Stacks

  13. Stack Applications • We consider two programs that use stacks • Palindrome finder • Parentheses matcher • First we consider palindrome finder • Palindrome: reads the same in either direction • For example: “level” and “Able was I ere I saw Elba” • Note that we do not ignore spaces and punctuation • So, for example, “never odd or even” not considered a palindrome for this exercise (but often it is) Chapter 5: Stacks

  14. Palindrome Finder • Input: string to be tested • Output: message indicating whether string is a palindrome or not • How to slove this problem? • Many different ways to solve this… • For example, could create a new string by going from end to beginning of original string • Then compare new and original strings • If equal, string is a palindrome • But we want to use a stack! Chapter 5: Stacks

  15. Palindrome Finder • Using a stack… • Push characters of original string onto stack • Then pop characters off and append to new string • Compare new string and original string • If same, then it is a palindrome • Why does this work? • If we push, then pop, it will reverse string Chapter 5: Stacks

  16. frank frank frank frank frank r r f r f a k f a n r f a n f Palindrome Finder • Suppose string is “frank” • First, push letters onto stack… Chapter 5: Stacks

  17. k kna knar knarf kn k n r f a n r r f a f r f a f Palindrome Finder • Then pop letters off of stack and append to new string… • Finally, compare original and new string: • We have frank != knarf, so not a palindrome Chapter 5: Stacks

  18. Class PalindromeFinder Chapter 5: Stacks

  19. Testing PalindromeFinder • What types of strings should be test??? • Single character (which is always a palindrome) • Single words • Both palindromes and non-palindromes • Multiple words • Both palindromes and non-palindromes • Different cases (upper/lower) • Even-length strings • Odd-length strings • Empty string (considered palindrome by default) Chapter 5: Stacks

  20. Balanced Parenthesis • It is important to determine whether an expression is “balanced” with respect to parentheses • For example • (a+b*(c/(d-e)))+(d/e) is balanced • But • (a+b*(c/d-e)))+(d/e) is not balanced • Problem is more complicated if braces or brackets (square and/or curly) are also used • Good solution is to use stacks! • Here, we only consider parenthesis Chapter 5: Stacks

  21. ParenChecker Class • Input: String (representing an expression) • Output: A message indicating whether expression is balanced with respect to parenthesis or not • Of course, we want to use a stack… • What is the idea behind the algorithm? • Push open parenthesis onto stack • When closed parenthesis is encountered • Try to pop top element off of stack • If no top element (stack is empty), not balanced • When done, if stack is not empty, then not balanced Chapter 5: Stacks

  22. ParenChecker Algorithm • Given expression to test… • Create an empty stack of characters • Set balanced = true (i.e., assume it is balanced) • Set index = 0 • While balanced is true and index < expression length • Get the next character in expression • If character in open parenthesis • Push open parenthesis onto stack • Else if character is closing parenthesis • If stack is empty, set balanced to false • Else pop element from stack • Increment index • Return true if balanced is true and stack is empty Chapter 5: Stacks

  23. ParenChecker Class Chapter 5: Stacks

  24. ParenChecker Testing • What data to test on? • Simple valid expressions (one level of matched parens) • Simple invalid expressions • More complex expressions (valid and invalid) • Test too many open parens and too many closed parens • Know the correct answer before testing an expression Chapter 5: Stacks

  25. Implementing a Stack • In Java, Stack class extends Vector • Could also have been implemented using other Lists • Such as ArrayList or LinkedList • Could also be implemented using Array • We’ll look (briefly) at each of these Chapter 5: Stacks

  26. a v a J Stack as a Vector • The Java API includes a Stack class as part of the package java.util • The Vector class implements a growable array • Elements of a vector accessed using an integer index • Size can grow or shrink as needed to accommodate the adding and removing of elements • In following examples, push letters of “Java” onto stack: Chapter 5: Stacks

  27. Stack as a Vector Chapter 5: Stacks

  28. Stack as a Vector • Java Stack is an extension of Vector • Therefore, can use all Vector methods on a Stack • Is this a good thing? • You can access any element of a Vector • So, you can access any element of a Stack • If you try to access elements of a Stack, you might get ArrayIndexOutOfBoundsException • Best to restrict yourself to stack-specific methods Chapter 5: Stacks

  29. Stack as a List • Can use ArrayList, Vector, LinkedList classes • Since all implement the List interface • Name of class illustrated in text is ListStack<E> • Note that ListStack is an adapter class • Gives different names to essentially same operations • Also true of Java’s Vector-based implementation • For example, java.util.Stack<E> push is code is public E push(E obj) { add(obj); return obj; } Chapter 5: Stacks

  30. ListStack.java publicclass ListStack < E > implements StackInt < E > { private List < E > theData; public ListStack() { theData = new ArrayList < E > (); } public E push(E obj) { theData.add(obj); return obj; } . . . Chapter 5: Stacks

  31. Stack as an Array • Allocate storage for an array with an initial default capacity when creating a new stack object • Keep track of the top of the stack, topOfStack • For empty stack, topOfStack is set to -1 • No size method • Array size does not grow/shrink after each push/pop • However, must reallocate if more space needed • This is very primitive • And that’s why I like it best… Chapter 5: Stacks

  32. Stack as an Array Chapter 5: Stacks

  33. Stack as an Array publicclass ArrayStack < E > implements StackInt < E > { E[] theData; int topOfStack = -1; privatestaticfinalint INITIAL_CAPACITY = 10; public ArrayStack() { theData = (E[])new Object[INITIAL_CAPACITY]; } public E push(E obj) { if (topOfStack == theData.length - 1) { reallocate(); } topOfStack++; theData[topOfStack] = obj; return obj; } . . . Chapter 5: Stacks

  34. Stack as a Linked List • Can implement a stack using a linked list of nodes • See code and details in text Chapter 5: Stacks

  35. Comparison of Stack Implementations • Extending a Vector (as is done by Java) is a poor choice • All Vector methods are accessible • Then why does Java do it this way? • What about ArrayList implementation? • Easiest to implement, ArrayList does all of the work… • What about Array implementation? • Slightly more difficult for programmer • What about Linked List implementation? • Uses only as much storage as needed • However, links are essentially wasted • Regardless of method used, push/pop is O(1) Chapter 5: Stacks

  36. Stack Application • We consider problem of evaluating math expressions • Postfix and infix notation • Expressions normally written in infix form • Operators (+,-,*,/, etc.) between the operands • Good for humans, not so good for computers • Computers prefer postfix notation • Operands come first, then operators Chapter 5: Stacks

  37. Postfix vs Infix Chapter 5: Stacks

  38. Postfix Advantages • Advantage of postfix form include • No need for parentheses • No need to consider operator precedence Chapter 5: Stacks

  39. Evaluating Postfix Expressions • Problem: Write a class to evaluate postfix expressions. • Analysis: Stack is good data structure to store operands until needed • Design: Class PostfixEvaluator with methods • Method eval: scans postfix expression and processes its tokens • Method evalOp: evaluates each operator • Method isOperator: determine whether a character is an operator Chapter 5: Stacks

  40. Evaluating Postfix Expressions Chapter 5: Stacks

  41. Evaluating Postfix Expressions Chapter 5: Stacks

  42. Evaluating Postfix Expressions Chapter 5: Stacks

  43. Converting Infix to Postfix Chapter 5: Stacks

  44. Converting Infix to Postfix Chapter 5: Stacks

  45. Converting Infix to Postfix Chapter 5: Stacks

  46. Converting Infix to Postfix Chapter 5: Stacks

  47. Converting Infix to Postfix Chapter 5: Stacks

  48. Chapter Review • A stack is a last-in, first-out (LIFO) data structure • A stack is a simple but powerful data structure • Four operations are empty, peek, pop, and push • Stacks are useful to process information in the reverse of the order that it is encountered • In Java, Stack is implemented as an extension of the Vector class Chapter 5: Stacks

  49. Chapter Review • We considered 3 different ways to implement a stack: • Using the List interface as a container • Using an array as a container • Using a linked list as a container • We applied stacks to evaluate arithmetic expressions Chapter 5: Stacks

More Related