stacks chapter 5. chapter objectives to learn about the stack data type and how to use its four...
Post on 18-Dec-2015
214 views
TRANSCRIPT
StacksStacks
Chapter 5Chapter 5
Chapter ObjectivesChapter 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
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
Stack Abstract Data TypeStack Abstract Data Type
A stack can be compared to a Pez dispenser Only the top item can be accessed Can only extract one item at a time
A stack is a data structure with the property that only the top element of the stack is accessible
The stack’s storage policy is Last-In, First-Out
A stack can be compared to a Pez dispenser Only the top item can be accessed Can only extract one item at a time
A stack is a data structure with the property that only the top element of the stack is accessible
The stack’s storage policy is Last-In, First-Out
Specification of the Stack Abstract Data Type
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
Need the ability to Inspect the top element Retrieve the top element Push a new element on the stack Test for an empty stack
Only the top element of a stack is visible, therefore the number of operations performed by a stack are few
Need the ability to Inspect the top element Retrieve the top element Push a new element on the stack Test for an empty stack
Specification of the Stack Abstract Data Type
(continued)
Specification of the Stack Abstract Data Type
(continued)
Stack ApplicationsStack Applications
Two client programs using stacks Palindrome finder Parentheses matcher
Palindrome: string that reads the same in either direction Example: “Able was I ere I saw Elba”
Two client programs using stacks Palindrome finder Parentheses matcher
Palindrome: string that reads the same in either direction Example: “Able was I ere I saw Elba”
Stack Applications (continued)Stack Applications (continued)
Stack Applications (continued)Stack Applications (continued)
When analyzing arithmetic expressions, it is important to determine whether an expression is balanced with respect to parentheses (a+b*(c/(d-e)))+(d/e)
Problem is further complicated if braces or brackets are used in conjunction with parenthesis
Solution is to use stacks!
When analyzing arithmetic expressions, it is important to determine whether an expression is balanced with respect to parentheses (a+b*(c/(d-e)))+(d/e)
Problem is further complicated if braces or brackets are used in conjunction with parenthesis
Solution is to use stacks!
Stack Applications (continued)Stack Applications (continued)
Stack Applications (continued)Stack Applications (continued)
Implementing a Stack as an Extension of Vector
Implementing a Stack as an Extension of Vector
The Java API includes a Stack class as part of the package java.util
The vector class implements a growable array of objects
Elements of a vector can be accessed using an integer index and the size can grow or shrink as needed to accommodate the adding and removing of elements
The Java API includes a Stack class as part of the package java.util
The vector class implements a growable array of objects
Elements of a vector can be accessed using an integer index and the size can grow or shrink as needed to accommodate the adding and removing of elements
Implementing a Stack as an Extension to Vector
(continued)
Implementing a Stack as an Extension to Vector
(continued)
Implementing a Stack with a List Component
Implementing a Stack with a List Component
Can use either the ArrayList, Vector, or the LinkedList classes as all implement the List interface
Name of class illustrated in text is ListStack<E> ListStack is an adapter class as it adapts the
methods available in another class to the interface its clients expect by giving different names to essentially the same operations
Can use either the ArrayList, Vector, or the LinkedList classes as all implement the List interface
Name of class illustrated in text is ListStack<E> ListStack is an adapter class as it adapts the
methods available in another class to the interface its clients expect by giving different names to essentially the same operations
Implementing a Stack Using an Array
Implementing a Stack Using an Array
Need to allocate storage for an array with an initial default capacity when creating a new stack object
Need to keep track of the top of the stack No size method
Need to allocate storage for an array with an initial default capacity when creating a new stack object
Need to keep track of the top of the stack No size method
Implementing a Stack Using an Array (continued)
Implementing a Stack Using an Array (continued)
Implementing a Stack as a Linked Data Structure
Implementing a Stack as a Linked Data Structure
We can implement a stack using a linked list of nodes
We can implement a stack using a linked list of nodes
Comparison of Stack Implementations
Comparison of Stack Implementations
Extending a Vector (as is done by Java) is a poor choice for stack implementation as all Vector methods are accessible
Easiest implementation would be to use an ArrayList component for storing data
All insertions and deletions are constant time regardless of the type of implementation discussed All insertions and deletions occur at one end
Extending a Vector (as is done by Java) is a poor choice for stack implementation as all Vector methods are accessible
Easiest implementation would be to use an ArrayList component for storing data
All insertions and deletions are constant time regardless of the type of implementation discussed All insertions and deletions occur at one end
Additional Stack ApplicationsAdditional Stack Applications
Consider two case studies that relate to evaluating arithmetic expressions Postfix and infix notation
Expressions normally written in infix form Binary operators inserted between their operands
A computer normally scans an expression string in the order that it is input; easier to evaluate an expression in postfix form
Consider two case studies that relate to evaluating arithmetic expressions Postfix and infix notation
Expressions normally written in infix form Binary operators inserted between their operands
A computer normally scans an expression string in the order that it is input; easier to evaluate an expression in postfix form
Additional Stack Applications (continued)
Additional Stack Applications (continued)
Additional Stack Applications (continued)
Additional Stack Applications (continued)
Advantage of postfix form is that there is no need to group subexpressions in parentheses
No need to consider operator precedence
Advantage of postfix form is that there is no need to group subexpressions in parentheses
No need to consider operator precedence
Evaluating Postfix ExpressionsEvaluating Postfix Expressions
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Converting from Infix to Postfix
Converting from Infix to Postfix
Additional Stack Applications (continued)
Additional Stack Applications (continued)
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Evaluating Postfix Expressions (continued)
Chapter ReviewChapter Review
A stack is a last-in, first-out (LIFO) data structure A stack is a simple but powerful data structure; its
four operations include empty, peek, pop, and push Stacks are useful to process information in the
reverse of the order that it is encountered Java.util.Stack is implemented as an extension of the
Vector class
A stack is a last-in, first-out (LIFO) data structure A stack is a simple but powerful data structure; its
four operations include empty, peek, pop, and push Stacks are useful to process information in the
reverse of the order that it is encountered Java.util.Stack is implemented as an extension of the
Vector class
Chapter Review (continued)Chapter Review (continued)
Three ways to implement a stack: Using an object of a class that implements the
List interface as a container Using an array as a container Using a linked list as a container
Stacks can be applied in programs for evaluating arithmetic expressions
Three ways to implement a stack: Using an object of a class that implements the
List interface as a container Using an array as a container Using a linked list as a container
Stacks can be applied in programs for evaluating arithmetic expressions