Embed Size (px)
Citation preview
04/21/23 1
CSC 1052
Outline Stacks
Basic operations Examples of use
Queues Basic operations Examples of use
Implementations Array-based and linked list-based
04/21/23 2
Static vs. Dynamic Structures
Recall that a static data structure has a fixed size
Arrays are static;
once you define the number of elements it can hold, it doesn’t change.
3
Objects
A dynamic data structure grows and shrinks as required by the information it contains.
We have examined a data structure where two objects can be instantiated and chained together
The next reference of one Node object refers to the other node.
This will create a linked list of Node objects.
04/21/23 4
Stacks A stack ADT is also linear, like a list or queue, It maintains its information in a straight line.
Items are added and removed from only one end of a stack.
It is therefore LIFO: Last-In, First-Out.
5
Stacks
Stacks are often drawn vertically:
6
removeadd
PUSH POP
A conceptual view of a stack
04/21/23 7
Stacks Some stack operations:
- push -add an item to the top of the stack.
- pop - remove an item from the top of the stack.
- peek - retrieves top item without removing it. - empty - returns true if the stack is empty.
8
Stacks
A stack is a structure of ordered items structure of ordered items such that items can be inserted and removed only at one end - called the called the top.top.
A stack is a LIFO or Last-in/First-Out structure.
Items are taken out of the stack in reverse order from their insertion.
04/21/23 9
Non-Computer Examples
Stack of papers Stack of bills Stack of plates
Expect O ( 1 ) time per stack operation.
(In other words, constant time per operation, no matter how many items are actually in the stack).
04/21/23 10
Stack
The stack specification lists a stack constructor and five methods.
One of the simplest stack implementations is to reverse a word.
Most compilers use stacks to analyze the syntax of a analyze the syntax of a program.program.
04/21/23 11
04/21/23 12
A
N
TAN
N
N
A
N
Using a Stack to reverse a wordPush N Push A Push T
Pop T Pop A POP N
Input NAT
Output TAN
STACKS applications
At all times in the execution of the reverse word program,
Only item can accessed from the stack,
This is the item on the TOP.
04/21/23 13
Peek()
We will use a method called peek() to view the top itempeek() to view the top item
It looks at the top item but does not remove it.
Stacks are also used frequently to evaluate expressions
04/21/2314
Applications – Evaluate expressions
Stacks can be used to check a program for balanced symbols (such as {}, (), []).
Example: {()} is legal, {(}) is not
(so simply counting symbols does not work).
04/21/23 15
Evaluate expressions
When a closing symbol is seen,
it must match the most recently seen unclosed opening symbol.
Therefore, a stack will be appropriate.
04/21/2316
Balanced Symbol Algorithm Make an empty stack.
Repeatedly read tokens(parenthesis); if the token is:
an opening symbol, push it onto the stack If it is a closing symbol
and the stack is empty, then report an error;
otherwise pop the stack and determine if the popped symbol is a match (if not report an error)
At the end of the file, if the stack is not empty, report an error.
04/21/23 17
Example Input: { ( ) }
Push {
Push ( stack now has { (
Pop - Next comes a ) , pop an item, it is ( which matches ).
Stack now has {
Pop – Next comes a } , pop an item, it is { which matches }.
End of file; stack is empty, so all is good.
04/21/23 18
({
{
Input: ( { } { } )
04/21/23 19
Empty Stack
( { ( (
{ ( (
Read and Push (
Read and Push {
Read first } , pop matching {
Read and Push 2nd {
Read 2nd }, pop matching {
Read ) and Pop (
04/21/23 20
Input: [ { } { } ]{}Initial Empty Stack
[
{
[ [
[
Read and Push [
Read and Push {
Read first }, pop matching {
Read and Push 2nd {
Read 2nd }, pop matching {
1 2 3 4
5 6
{ [
And so on..
Performance Running time is O( N ),
where N is amount of data (that is, number of tokens).
Algorithm is online:
it processes the input sequentially, never needing to backtrack.
04/21/23 21
Balancing an expression In the method IsBalanced(String exp) an expression is
checked to see if all the parentheses match.
A charStack is set up whose legal characters are:“() {} [} “
A switch is used
04/21/23 22
Method Stack Matching symbols is similar to method call and
method return,
because when a method returns, it returns to the most recently active method.
A method stack can be used to keep track of this.
04/21/23 23
Method call and return
Abstract idea:
when a method call is made,
save current state of the method on a stack.
On return,
restore the state by popping the stack.
04/21/2324
Stack Frames or Activation Records Programs compiled from modern high level languages
make use of a
stack frame for the working memory of each method invocation.
When any method is called, a number of words - the
stack frame - is pushed onto a program stack. When the method returns, this frame of data is popped
off the stack.
04/21/23 25
Stack frame or Activation Record
The Stack Frame or Record contains the :
Method arguments
Return address
And local variables of the method to be stored
04/21/23 26
04/21/23 27
Context for execution of f:f:Each frame contains :parameters, return address and local variablesparameters, return address and local variables
method f( int x, int y) { int a; if ( end_cond ) return …; a = ….; return g( a ); }
method g( int z ) { int p, q; p = …. ; q = …. ; return f(p,q); }
Activation Records As a method calls another method,
first its arguments,
then the return address and
finally space for local variables is pushed onto the stack. space for local variables is pushed onto the stack.
04/21/23 28
current method environment.
The top of stack stores the current method environment.
When the method is called,
the new environment(parameters etc.) is pushed onto stack.
When the method ends and returns,
the old environment is restored by popping the method environment.
04/21/2329
Stack Frames
Since each function runs in its own "environment" or context,
it becomes possible for a function to call itself - a technique known as recursionrecursion. .
This capability is extremely useful and extensively used
- because many problems are elegantly specified or solved in a recursive way.
04/21/23 30
Stack Frames The most common applications for stacks have a space
restraint
so that using an array implementation for a Stack is a natural and efficient one.
In most operating systems, allocation and de-allocation of memory costs time and space , e.g.
there is a penalty for the flexibility of linked list implementations..
04/21/23 31
Array Implementations Stacks can be implemented with
an array and
an integer top that that stores the array index of the top of stores the array index of the top of the stack.the stack.
Empty stack has top equal to -1.top equal to -1.
04/21/23 32
Operations of a Stack
To push an object on the stack To push an object on the stack ,
increment the top counter, and write in the array position.
To pop an item from the stack: decrement the top counter.
04/21/2333
Stages
04/21/23 34
A
B top(1)top(-1) A top(0)
Array Doubling If stack is full (because array size has been reached), we
can extend the array, using array doubling.
We allocate a new, double-sized array and copy contents over:
array =[T] new Object[ OldArray.length * 2 ];
for( int j = 0; j < OldArray.length; j++ )
Array[ j ] = OldArray[ j ];
OldArray = array;
04/21/23 35
Running Time Without array doubling,
all operations are constant time, and
They do not depend on number of items in the stack.
With array doubling,
A push could occasionally be O( N ).
04/21/23 36
Big O of Stack
However, However,
if the if the array doubling occurs infrequently,array doubling occurs infrequently,
it is it is essentially essentially OO( 1 ) ( 1 )
because because each array doubling that costs each array doubling that costs NN assignments assignments
is is preceded by preceded by NN/2 non-doubling pushes./2 non-doubling pushes.
04/21/2337
04/21/23 38
Infix Expressions Example: 1 + 2 * ( 3 + 4 )
Operands appear both before and after operator.
When there are several operators,
precedence and associativity determine how operators are processed.
04/21/23 39
Precedence and Associativity Precedence: used to decide which of two operators
should be processed.
Associativity: used to decide which of two operators should be processed when both operators have the same precedence.
Exponentiation: Right to Left
Multiplication/Division: Left to Right
Addition/Subtraction: Left to Right
04/21/23 40
Examples
4-4-4 evaluates to -4
2^2^3 evaluates to 256
Parenthesis override precedence and associativity.
04/21/23 41
04/21/23 42
Evaluating Infix expressionsEvaluating Infix expressions
In developing an application to use a stack to evaluate an infix expression,
several items must be considered.
A fully parenthized expression can be evaluated using the Stack data structure.
The implementation is complicated because of necessity for two stacks:
1. Operator stack to store unprocessed operators.
2. Operand stack to store unprocessed operands The time analysis is:
2n reads/peeks + n operations + 3n pushed + 3n popped = 9n
04/21/2343
Difficulty of Infix Evaluation Infix evaluation is difficult because of precedence rules:
when an operator is seen, it may or may not need to be deferred.
if it has a lower precedence than an operator further along in the expression.
Even if operator needs to be used, the second operand has still not been processed.
1 + 2 * …
04/21/23 44
Postfix Expressions An alternate form is the postfix expression
Let's examine a program that uses a stack to evaluate postfix expressions
In a postfix expression, the operator comes after its two operands
04/21/23 45
Infix to Postfix
We generally use infix notation, with parentheses to force precedence:
(3 + 4) * 2
In postfix notation, this would be written
3 4 + 2 *
In postfix, when you come to an operator, you already have it operands
04/21/2346
Postfix Example – Let’s solve it 1 2 3 * +
Push 1, Push 2, Push 3.
When * is seen, Pop 3, Pop 2, evaluate 2 * 3, and Push the result 6.
When + is seen, Pop 6, Pop 1, evaluate 1 + 6, and Push the result 7.
At end of expression, stack should have one item,
which is the answer.
04/21/23 47
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, only the answer will be on the stack
04/21/23 48
Postfix Example, Continued
04/21/23 49
71 1 1 12 2
36
Push 1 Push 2 Push 3 Pop 3
Pop 2
Push 6
Pop 6
Pop 1
Push 7
1 2 3 * +
The following operations will store the expression on the stack. As an operator is encountered the operators are popped and the appropriate operation performed.
WHEN YOU THE FIRST OPERATOR IS MET, -- THE *, POP THE 3 AND THE 2 , MULTIPLY THEM
AND STORE THE PRODUCT - 6 – ON THE STACK
When the last operator (+) is met, When the last operator (+) is met, pop 6 and 1 and add them, andpop 6 and 1 and add them, andpush the result on the stackpush the result on the stack
OLD COMPILERS translated infix expressions using two stacks into machine language.AN OPERATOR IS PLACED BETWEEN ITS OPERANDS
c – d + (e * f – g * h) / i
INFIX MACHINE LANGUAGE
THIS GETS MESSY BECAUSE OF PARENTHESES
AND NEED FOR TWO STACKS
NEWER COMPILERS:
INFIX POSTFIX MACHINE LANGUAGE
04/21/23 51
IN POSTFIX NOTATION, AN OPERATOR IS PLACED
IMMEDIATELY AFTER ITS OPERANDS.
INFIX
POSTFIX
a + b
ab+
a + b * c
abc*+
a * b + c
ab*c+
(a + b) * c
ab+c*
PARENTHESES NOT NEEDED – AND NOT USED – IN POSTFIX
Infix to Postfix Conversion
By converting infix expressions to postfix, an expression can be easily evaluated.
This computer first changes infix to postfix and theN solves the postfix expression
04/21/23 52
Infix to Postfix
The basic algorithm is operator precedence parsing.
When an operand is seen, it is immediately output. Below we write out the 1
What happens when an + operator is seen?
1 + 2 * ( 3 + 4 )
04/21/2353
Infix to Postfix Conversion When an operator is seen, When an operator is seen,
it can never be output immediately,
because the second operand has not been seen yet.
The operator must be saved, and eventually output.
A stack is used to store operators that have been seen but not yet output.
04/21/23 54
Operator Stack In an expression such as :
infix expression - 1 + 2 * 3 ^ 4 + 5 postfix expression - 1 2 3 4 ^ * + 5 +.
Infix expression - 1*2+3^4+5 postfix expression - 1 2 * 3 4 ^ + 5 +.
In both cases, when the second operator is about to be processed, we have output 1 and 2, and there is one operand on the stack.
04/21/23 55
Exiting the Operator Stack The question is:
How do operators exit the stack?
An operator exits the stack if the precedence and associativity rules indicate that
it should be processed instead of the current operator.
04/21/23 56
Precedence Rules
Basic rule:
If the current operator has a lower precedence than the operator on the top of the stack,
then the top of stack operator exits the stack.
04/21/2357
Equal precedence Associativity rules decide what to do if current operator
has same precedence as operator on the top of stack.
If operators are left associative, stack operator is popped 4-4-4 = 4 4 - 4 –
If operators are right associative, stack operator is not popped.
2^2^3 = 2 2 3 ^ ^
04/21/23 58
04/21/23 59
LET’S CONVERT AN INFIX STRING TO A POSTFIX STRING. x – y * z
04/21/23 60
INFIX POSTFIX
x – y * z x
We write out the x to postfix and move to the operator -We write out the x to postfix and move to the operator -
04/21/23 61
INFIX POSTFIX
x – y * z x
We do not yet have the operands for the “-”
SO ‘-’ MUST BE TEMPORARILY SAVED SOMEWHERE.
04/21/23 62
INFIX POSTFIX
x – y * z xy
We put ‘-’ on the stack and write the Y to postfix
-
04/21/23 63
INFIX POSTFIX
x – y * z xy
THE OPERANDS FOR ‘*’ ARE NOT YET IN POSTFIX,
SO ‘*’ MUST BE TEMPORARILY saved on the stack ,
AND ‘*’ has a higher precedence than ‘-’.,
so it is pushed on the stack.
*-
Exiting the Stack
The rule is that the an operator:
does not exit the stack
Unless it has a higher precedence than the operator being considered
The minus sign has lower precedence than the *
04/21/2364
*-
04/21/23 65
INFIX POSTFIX
x – y * z xyz
INFIX POSTFIX
x – y * z xyz* –
We Come to the end of the infix expression and so pop all the operators.
*-
04/21/23 66
INFIX POSTFIX
x – y * z xyz* –
04/21/23 67
THE TEMPORARY STORAGE FACILITY IS A STACK.
FOR EACH OPERATOR IN THE INFIX EXPRESSION:
LOOP UNTIL an OPERATOR IS TO BE PUSHED:
IF OPERATOR STACK IS EMPTY,
PUSH OPERATOR ON THE STACK
ELSE IF INFIX OPERATOR HAS GREATER PRECEDENCE
THAN TOP OPERATOR ON STACK,
PUSH THE INFIX OPERATOR ON THE STACK
ELSEELSE
POP OPERATOR ON STACK AND APPEND TO POSTFIX EXPRESION
Infix expression - 1 * 2 + 3 ^ 4 + 5 postfix expression - 1 2 * 3 4 ^ + 5 +.1. Write the 1 to output
2. Put * on the stack
3. Write the 2 to output
4. The + has lower precedence to the *, so pop the * , write it out and put the + on the stack
5. Write out the 3 and put the ^ on the stack
6. Write out the 4, the + has lowest precedence so pop
^ and the + (associativity) and push the + on the stack
7. Write out the 5, no more input so pop stack
04/21/2368
Output: 1 2 * 3 4 ^ + 5 +
2. *
5. ^ +
4. +
6. +
04/21/23 69
WHAT ABOUT PARENTHESES? LEFT PARENTHESIS: HAS LOWEST PRECEDENCE SO PUSH ON THE STACK RIGHT PARENTHESIS: POP ALL OPERATORS AND APPEND THEM TO POSTFIX UNTIL THE ‘(‘ IS MET. DISCARD ‘(‘
04/21/23 70
STACK APPLICATION
CONVERTING FROM INFIX TO POSTFIX
Multiple Stack Exits In expression such as 1+2*3^4+5, with postfix
equivalent:
1 2 3 4 ^ * + 5 +
when second + is seen, ^ * + are all popped.
Thus, several exits can occur on one symbol.
04/21/23 71
Infix to Postfix Example
04/21/23 72
1
1 --
2
2-
^-^ 3
3-^
^-^^
3
3-^^ ^^-
--
(-( 4
4-(
+-(+
5
5-(+
*-
6
6
+ *+
)-
*-* 7
7-* *-(
+*
-(
*
Infix: 1 – 2 ^ 3 ^ 3 - ( 4 + 5 * 6 ) * 7Postfix: 1 2 3 3 ^ ^ - 4 5 6 * + 7 * -
Parentheses The Left parenthesis is the higher precedence operator when it
is an input symbol
(meaning that it is always pushed on the stack).
Left parenthesis is a lower precedence operator when it is on the stack. Only a right parenthesis can pop it
Right parenthesis pops the stack until a left parenthesis is met and then pops the left parens
Operators are written to output, but parenthesis are discarded.
04/21/23 73
Algorithm Summary infix - postfix
Operands: Immediately output. Left parenthesis: push on the stack
Right parenthesis: Pop stack symbols until an open parenthesis is seen. Pop and discard left parens.
Operator: Pop all stack symbols until (1) Stack is empty (2) Meet a left parenthesis (3) we see a symbol of lower precedence, or a right-
associative symbol of equal precedence. (4) Then push the operator.
End of input: Pop all remaining symbols.
04/21/23 74
Precedence Table The Algorithm is implemented by use of a precedence
table;
associativity can be incorporated into precedences.
Each symbol has two precedences: one as current symbol, one as top of operator stack.
04/21/23 75
The LinkedStack Class
Now let's examine a linked implementation of a stack
We will reuse the LinearNode class that we used in LinkedList implementation 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
04/21/23 76
A linked implementation of a stack
04/21/23 77
LinkedStack - the push Operation
04/21/23 78
Top is declared at the top of the class as:
LinearNode top ( similar to head)
What method is this similar to?
The stack after pushing element T
04/21/23 79
LinkedStack - the pop Operation
04/21/23 80
What method is this similar to?
The stack after a pop operation
04/21/23 81
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 T 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
04/21/23 82
An array implementation of a stack
04/21/23 83
ArrayStack - the push Operation
04/21/23 84
//----------------------------------------------------------------- // 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();
// store the element in the array // increment top }
The stack after pushing element E
04/21/23 85
ArrayStack - the pop Operation
04/21/23 86
//----------------------------------------------------------------- // Removes the element at the top of the stack and returns a // reference to it. Throws an EmptyStackException if the stack // is empty. //----------------------------------------------------------------- public T pop() throws EmptyStackException { if (isEmpty()) throw new EmptyStackException();
// decrement top; // store the element in top –in an object of type T to return it // set top of stack to null return result; }
The stack after popping the top element
04/21/23 87
The java.util.Stack Class
The Java Collections framework defines a Stack with similar operations
It is derived from the Vector class and thus has methods that are not appropriate for a 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.
04/21/23 88
Stacks The java.util package contains a Stack class that is
implemented using a Vector.
It contains methods that correspond to standard stack operations plus method that returns an integer corresponding to the position in the stack of the particular object.
This type of searching is not usually considered to be part of the classic stack ADT.
04/21/23 89
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
04/21/23 90
Collections Framework
Let’s review more about the properties that all the Let’s review more about the properties that all the collection classes have in common:collection classes have in common:
Allow the collection size to increase dynamically All only hold items that are generic - T
Provides at least two constructors – one to create an empty collection and one that accepts as a parameter any other collection
object and creates a new collection object that holds the same information.
04/21/23 91
Collections Framework The collections differ in:
Logical structure of the elements they contain The underlying implementation’
The efficiency of the various operations The set of supported operations
Whether they allow duplicates Whether they allow keys
Whether the elements are sorted
04/21/23 92
Collections Framework
The Vector class has been replaced by the ArrayList class which provides the same methods in a single thread environment.
The HashTable class also supports synchronization so for single thread programs you should use HashMap.
The Stack class of the Collections Framework is implemented with a Vector. There are the expected problems with performance due to concurrency and a logical error. Vectors allow access anywhere in the array, stacks do not.
04/21/23 93
Collections Framework
The Collection Interface is used by classes that do not support a unique key value, e.g. unkeyed lists and sets.
Some methods in the interface are:
boolean Add(T obj) - adds obj to Collection boolean addAll(Collection c) –add c to Collection boolean contains(T obj) – return true if obj is
in Collection boolean isEmpty() - returns true if collection is empty
04/21/23 94
Collections Framework
The MAP interface::
This interface is used by library collection classes that map unique keys to values.
It defines a method to retrieve an object based on its key value.
Classes that implement the MAP interface are:
AbstractMap, HashMap and HashTable.
04/21/23 95
Collections Framework
The AbstractCollection Class implements the Collection interface. The Collection interface defines 15 operations
Some of these methods define fundamental operations which will vary with the particular collection. Others will be the same no matter what the implementation, e.g.
The size method will depend upon the implementation so it is an abstract method but the isEmpty() method can be implemented as:
public boolean isEmpty() { return (this.size() == 0)
}
04/21/23 96
Collections Framework
By defining as many methods as possible in terms of the fundamental operations, the AbstractCollection class cuts down on the time to implement a new collection.
In addition, two other abstract classes extend the AbstractCollection class – AbstractSet and AbstractList.
Both these classes perform the same services as the
AbstractCollection class
Finally, concrete classes extend AbstractSet and AbstractList.
04/21/23 97
04/21/23 98
Collection List Set AbstractList AbstractSet ArrayList LinkedList HashSet TreeSet
interface abstract class fully-defined class
