Stack

1
Chapter 7

• Stack

2
Overview

• The stack data structure uses an underlying
  linear storage organization.
• The stack is one of the most ubiquitous data
  structures in computing.

3
Learning Objectives

• Describe the behavior of a stack.
• Enumerate the primary operations supported by the
  stack.
• Examine several applications of the stack,
  including parentheses matching, evaluating
  postfix expressions, and the conversion of an
  infix expression to postfix form.
• Understand the public interface of a stack class
  in Java and the running times of its methods.

4
Learning Objectives

• Develop a postfix package in Java to implement
  postfix expression evaluation.
• Study the implementation of a stack class in
  Java, and the trade-offs involved in choosing
  between candidate reusable components.

5
7.1 Stack Properties

• Surfing the Web on a browser
• The sequence of back clicks loads the browser
  with Web pages in reverse order of visit.
• The last visited page is the first loaded when
  going back.
• A stack is a collection of entries that
  demonstrates exactly this last in, first out
  behavior, called LIFO in short.

6
7.1 Stack Properties
7
7.1 Stack Properties

• An entry added or pushes on to the top of a
  stack.
• An entry is removed, or popped from the top of
  stack.

8
7.1 Stack Properties
9
Results of Stack Operations Using StackNode
(Contd)
10
Results of Stack Operations Using StackNode
(Contd)
11
Results of Stack Operations Using StackNode
(Contd)
12
Results of Stack Operations Using StackNode
(Contd)
13
Results of push Operation
14
Results of push Operation (Contd)
15
Results of push Operation (Contd)
16
Results of push Operation (Contd)
17
Results of pop Operation
top top.next
18
7.2.2 Postfix Expression Evaluation

• We write arithmetic expressions like so
• Consider the expression
• It cannot simply be scan left to right.

19
7.2.2 Postfix Expression Evaluation

• Postfix, does away with the need for parentheses.
• An operator always follows the operands or
  sub-expressions on which it operates.

20
7.2.2 Postfix Expression Evaluation
21
7.2.2 Postfix Expression Evaluation
22
7.2.2 Postfix Expression Evaluation

• Two conditions that must be met for the
  evaluation process to terminate successfully
• When an operator is encountered, there must exist
  a most recent pair of operands or temporary
  results for application.
• When the scanning of the expression is complete,
  there must be exactly one value on the stack.

23
7.2.2 Postfix Expression Evaluation
24
7.2.2 Postfix Expression Evaluation

• Two possible errors that may be encountered by
  the algorithm
• One is that of insufficient operands.
• The other is that of too many operands.
• Insufficient operands case is detected when the
  token is an operator, but the stack has less than
  the two operands on which the operator must be
  applied.
• Too many operands case is detected after the
  while loop, when the stack has more than one
  entry in it.

25
7.3 A Stack Class
26
7.3 A Stack Class
27
7.4 A Postfix Expression Evaluation Package

• Every step of the evaluation processes one token
  of the expression.

28
7.4.1 Class PostfixEvaluator
29
7.4.1 Class PostfixEvaluator

• java.util.StringTokenizer parses the postfix
  expression into tokens and deals them out one at
  a time.
• StackKeeper maintains the evaluation stack.

30
7.4.1 Class PostfixEvaluator
31
7.4.1 Class PostfixEvaluator

• RunAll message evaluates and produces the results
  in one shot.
• Restart the evaluator by the init message.

32
7.4.3 Class StackKeeper
33
7.4.3 Class StackKeeper
34
7.4.3 Class StackKeeper
35
7.4.3 Class StackKeeper
36
7.4.4 Class PostfixEvaluator Implementation
37
7.4.4 Class PostfixEvaluator Implementation

• The StringTokenizer method count Tokens returns
  the number of tokens that remain to be
  enumerated.
• At the end of the run, the stack must contain
  exactly one element.

38
7.4.4 Class PostfixEvaluator Implementation

• The NoSuchElementException does two things
• Prints the current evaluation status so the
  calling application gets as much information as
  possible about the source of the exception.
• Throws an IllegalExpressionException, in order to
  deliver the most precise and complete information
  about the cause of the exception.
• This is much better than just passing through the
  NoSuchElementException, which, in this context,
  is not informative enough.

39
7.5.1 Design1 Array List for Storage

• Using an instance of the ArrayList class as a
  component in the Stack class.

40
7.5.2 Design 2 Linked List for Storage

• Which end of the list should be used for the
  pushes and pops?
• Addition could be done at either end on O(1)
  time.
• Deletion from the front can be done in O(1) time,
  deletion from the rear can only be done in O(n)
  time.

41
7.5.2 Design 2 Linked List for Storage
42
7.5.2 Design 2 Linked List for Storage
43
7.5.2 Design 2 Linked List for Storage
44
7.5.2 Design 2 Linked List for Storage

• The insertAt (item, index) method takes O(n) time
  in the worst case, but insertAt (item, 0) only
  times O(1) time.
• The removeAt (index) method takes O(n) time in
  the worst case, but removeAt (0) only takes O(1)
  time.

45
7.6 Summary

• The stack data structure implements the Last In
  First Out (LIFO) abstraction.
• A stack is a linear collection of entires in
  which, for every entry y that enters the stack
  after another entry x, y leaves the stack before
  x.
• A stack memorizes things and recalls them in
  reverse order.
• There are two fundamental operations supported by
  a stack push and pop.

46
7.6 Summary

• Every infix expression can be written
  unambiguously in postfix form.
• A postfix expression can be evaluated by using a
  stack with a single left-to-right scan of the
  expression.
• A stack class in Java may define more than just
  the fundamental push and pop methods in its
  interface in order to provide better efficiency
  and ease of use.

47
7.6 Summary

• A stack is a powerful tool for parentheses
  matching, or in general, matching entities that
  must occur in opening and closing pairs.
• An infix expression may be converted in O(n)
  (linear) time into the equivalent infix form,
  using a stack.
• A stack class may be implemented using a vector
  or a linked list as component, with careful
  attention being paid to the end at which push
  and pop are performed in order to maintain O(1)
  time for these operations.