Ch06 Stack

Chapter 6

Stacks

Copyright © 2005 Pearson Addison-Wesley. All rights reserved. 6-2

Chapter Objectives

• Examine stack processing

• Define a stack abstract data type

• Demonstrate how a stack can be used to solve problems

• Examine various stack implementations

• Compare stack implementations


Stacks

• A stack is a linear collection whose elements are added and removed from one end

• A stack is LIFO – last in, first out

• The last element to be put on the stack is the first element to be removed

• A stack is usually depicted vertically, with additions and deletions occurring at the top of the stack


FIGURE 6.1 A conceptual view of a stack


FIGURE 6.2 The operations on a stack


FIGURE 6.3 The StackADT interface in UML


Listing 6.1


Using Stacks

• Stacks are particularly helpful when solving certain types of problems

• Consider the undo operation in an application– keeps track of the most recent operations

in reverse order


Postfix Expressions

• Let's examine a program that uses a stack to evaluate postfix expressions

• In a postfix expression, the operator comes after its two operands

• We generally use infix notation, with parentheses to force precedence:

(3 + 4) * 2

• In postfix notation, this would be written3 4 + 2 *


Postfix Expressions

• To evaluate a postfix expression:– scan from left to right, determining if the next

token is an operator or operand

– if it is an operand, push it on the stack

– if it is an operator, pop the stack twice to get the two operands, perform the operation, and push the result onto the stack

• At the end, there will be one value on the stack, which is the value of the expression


FIGURE 6.4 Using a stack to evaluate a postfix expression


Postfix Expressions

• To simplify the example, let's assume the operands to the expressions are integer literals

• Our solution uses an ArrayStack, though any implementation of a stack would suffice


Listing 6.2


Listing 6.2 (cont.)


Listing 6.3


Listing 6.3 (cont.)


FIGURE 6.5 A UML class diagram for the postfix expression program


Using Stacks - Traversing a Maze

• A classic use of a stack is to keep track of alternatives in maze traversal or other trial and error algorithms

• Using a stack in this way simulates recursion – Recursion is when a method calls itself

either directly or indirectly



• Run-time environments keep track of method calls by placing an activation record for each called method on the run-time stack

• When a method completes execution, it is popped from the stack and control returns to the method that called it– Which is now the activation record on the top of

the stack



• In this manner, we can traverse a maze by trial and error by using a stack to keep track of moves that have not yet been tried


Listing 6.4


Listing 6.4 (cont.)


Listing 6.5


Listing 6.5 (cont.)


The LinkedStack Class

• Now let's examine a linked implementation of a stack

• We will reuse the LinearNode class that we used in Chapter 3 to define the linked implementation of a set collection

• Internally, a stack is represented as a linked list of nodes, with a reference to the top of the stack and an integer count of the number of nodes in the stack


FIGURE 6.6 A linked implementation of a stack


LinkedStack - the push Operation


FIGURE 6.7 The stack after pushing element E


LinkedStack - the pop Operation


FIGURE 6.8 The stack after a pop operation


The ArrayStack Class• Now let's examine an array-based

implementation of a stack

• We'll make the following design decisions:– maintain an array of Object references

– the bottom of the stack is at index 0

– the elements of the stack are in order and contiguous

– an integer variable top stores the index of the next available slot in the array

• This approach allows the stack to grow and shrink at the higher indexes


FIGURE 6.9 An array implementation of a stack


ArrayStack - the push Operation

//----------------------------------------------------------------- // Adds the specified element to the top of the stack, expanding // the capacity of the stack array if necessary. //----------------------------------------------------------------- public void push (T element) { if (size() == stack.length) expandCapacity();

stack[top] = element; top++; }


FIGURE 6.10 The stack after pushing element E


ArrayStack - the pop Operation


FIGURE 6.11 The stack after popping the top element


The java.util.Stack Class

• The Java Collections framework defines a Stack class with similar operations

• It is derived from the Vector class and therefore has some characteristics that are not appropriate for a pure stack

• The java.util.Stack class has been around since the original version of Java, and has been retrofitted to meld with the Collections framework


FIGURE 6.12 A UML description of the java.util.Stack class


Analysis of Stack Operations

• Because stack operations all work on one end of the collection, they are generally efficient

• The push and pop operations, for both linked and array implementations, are O(1)

• Likewise, the other operations for all implementations are O(1)

• We'll see that other collections (which don't have that characteristic) aren't as efficient for all operations

Ch06 Stack

Technology

Transcript of Ch06 Stack