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. 7.2.1 Parentheses Matching
A compiler checks expressions in a program to ensure that all parentheses are matched.
Good text editors match parentheses on-the-fly.
On typing a closing parenthesis, the user is shown the companion opening parenthesis.
A closing parenthesis matches the latest opening parenthesis.
In implementing the matching, opening parenthesis need to be stored when encountered, and recalled in reverse order whenever closing parentheses are encountered.

10. 7.2.1 Parentheses Matching
It is redundant to explicitly store opening parentheses in a stack that can only contain opening parentheses.
The location of the opening parenthesis needs to be stored.
When the user types an opening parenthesis, the text editor could push its location on stack.
When a closing parenthesis is typed, the location of the top of the stack is popped and used to address the matching opening parenthesis in the text.

11. 7.2.2 Postfix Expression Evaluation
We write arithmetic expressions like so:
Consider the expression:
It cannot simply be scan left to right.

12. 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.

13. 7.2.2 Postfix Expression Evaluation

14. 7.2.2 Postfix Expression Evaluation

15. 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.

16. 7.2.2 Postfix Expression Evaluation

17. 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.

18. 7.2.3 Infix to Postfix Conversion
Convert an infix expression to postfix form.
Algorithm does one simple scan of the input.
Algorithm takes O(n) time.

19. 7.2.3 Infix to Postfix Conversion

20. 7.2.3 Infix to Postfix Conversion

21. 7.3 A Stack Class

22. 7.3 A Stack Class

23. 7.4 A Postfix Expression Evaluation Package

24. 7.4 A Postfix Expression Evaluation Package

25. 7.4 A Postfix Expression Evaluation Package
Every step of the evaluation processes one token of the expression.

26. 7.4.1 Class PostfixEvaluator

27. 7.4.1 Class PostfixEvaluator

28. 7.4.1 Class PostfixEvaluator
This class responds to different events or messages.
A message sent to a PostEvaluator object results in some action being performed depending on the type of message sent.
java.util.StringTokenizer parses the postfix expression into tokens and deals them out one at a time.
StatusKeeper keeps track of the portion of the expression that has been processed so far.
StackKeeper maintains the evaluation stack.

29. 7.4.1 Class PostfixEvaluator

30. 7.4.1 Class PostfixEvaluator
RunAll message evaluates and produces the results in one shot.
RunSome performs partial evaluations, interspersing these messages with printStatus messages to watch the action.
Restart the evaluator by the init message.

31. 7.4.1 Class PostfixEvaluator
“25 12” has already been process just before runSome performs the step that is illustrated.

32. 7.4.2 Class StatusKeeper

33. 7.4.2 Class StatusKeeper
The status of the evaluator is the expression processed so far.
Every time a token is processed, and update is invoked, the status is appended by appending this token to the status buffer.
At the end of processing the status buffer will contain the complete input expression.

34. 7.4.3 Class StackKeeper

35. 7.4.3 Class StackKeeper

36. 7.4.3 Class StackKeeper

37. 7.4.3 Class StackKeeper

38. 7.4.3 Class StackKeeper

39. 7.4.4 Class PostfixEvaluator Implementation

40. 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.

41. 7.4.4 Class PostfixEvaluator Implementation

42. 7.4.4 Class PostfixEvaluator Implementation

43. 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.

44. 7.5.1 Design1: Array List for Storage
Using an instance of the ArrayList class as a component in the Stack class.

45. 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.

46. 7.5.2 Design 2: Linked List for Storage

47. 7.5.2 Design 2: Linked List for Storage

48. 7.5.2 Design 2: Linked List for Storage

49. 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.

50. 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.

51. 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.

52. 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.