chapter 05 compiled by: dr. mohammad omar alhawarat stacks & queues
TRANSCRIPT
CHAPTER 05
Compiled by: Dr. Mohammad Omar Alhawarat Stacks & Queues
Overview Stacks and Queues
Data structure holding a collection of objects, ordered by when they were inserted into the structure.
Stack can access newest object. Queue can access oldest object.
2
3
Stacks
A stack is a linear collection whose elements are added and removed from the same end
Stacks are processed in a last in, first out (LIFO) manner
Usually, stacks are depicted vertically, and we refer to the top of the stack as the end to which elements are added and removed
4
Stack Operations
push: places an element onto the top of a stack
pop: removes an element from the top of the stack
peek: which retrieves (copies) a value from the top of the stack without removing it
isempty: an operation to determine whether or not the stack is empty
empty: an operation to empty out a stack
The Stack Interface5
The Stack Interface
Iast-in, first-out or LIFO policy Last item pushed on the stack is next item
popped off the stack. Example:
A stack of plates.
6
The Stack Interface7
8
Push
Push means place a new data element at the top of the stack
17
5
11
3
9
Push (cont.)
Push means place a new data element at the top of the stack
17
5
11
3
10
Push (cont.)
Push means place a new data element at the top of the stack
17
5
11
3
11
Push (cont.)
Push means place a new data element at the top of the stack
17
5
11
3
12
Pop
Pop means take a data element off the top of the stack
17
5
11
3
13
Pop (cont.)
Pop means take a data element off the top of the stack
17
5
11
3
14
Pop (cont.)
Pop means take a data element off the top of the stack
17
5
11
3
15
Pop (cont.)
Pop means take a data element off the top of the stack
17
5
11
3
16
Peek
Peek means retrieve the top of the stack without removing it
17
5
11
3
17
Peek (cont.)
Peek means retrieve the top of the stack without removing it
17
5
11
3
3
18
Peek (cont.)
Peek means retrieve the top of the stack without removing it
17
5
11
3
3
19
Linked-List Stack
Stacks can be implemented with a linked list
The front node is the top of the stack
20
Linked-List Stack (cont.)
top
To pop, we remove the node at the front of the linked list, and return the element to the client…
21
Linked-List Stack (cont.)
top
To pop, we remove the node at the front of the linked list, and return the element to the client…
22
Linked-List Stack (cont.)
top
To push, we place the new element in a node and insert it at the front of the linked list…
The Program (Call) Stack
When a method is called Runtime environment creates activation
record Shows method's state during execution
Activation record pushed onto the program stack (Java stack) Top of stack belongs to currently executing
method Next method down is the one that called
current method
23
The Program Stack
The program stack at 3 points in time; (a) when main begins execution; (b) when methodA begins execution, (c) when methodB begins execution.
24
25
Evaluating Postfix Expressions
Before looking further at the implementation of a stack, let's first see how one might be used
Arithmetic operations are traditionally written in infix notation, meaning that the operator is placed between its operands in the form
<operand> <operator> <operand> When evaluating infix expressions, we rely on
precedence rules to determine the order of operator evaluation
In a postfix expression, the operator comes after its two operands
<operand> <operand> <operator>
26
Evaluating Postfix Expressions
The process of evaluating a postfix expression can be stated simply: scan from left to right, apply each operation to the two previous
operands immediately preceding it and replace the operator with the result
Consider the infix expression: 4 + 5 * 2
In postfix notation, it would be written as: 4 5 2 * +
27
Evaluating Postfix Expressions
Consider the design of a program that can compute the result of a postfix expression
The evaluation rule relies on being able to retrieve the previous two operands whenever we encounter an operator
A large postfix expression will have many operators and operands to manage
A stack is the perfect collection to use in this solution
28
Evaluating Postfix Expressions
Solution algorithm: scan the expression from left to right, identifying
each token as an operator or operand if the scanned token is an operand, push it onto the
stack if the scanned token is an operator
pop the top two elements off the stack, apply the operation to them, and push the result onto the stack
If we reach the end of the expression the remaining element on the stack is the result of the expression (otherwise the expression was not well formed)
29
Using a Stack to Evaluate a Postfix Expression
Given the expression: 7 4 -3 * 1 5 + / *
7top
4
-3
*
1
5
+
/
-12
6
-2
-14
*
Infix-to-Postfix Algorithm
Symbol in Infix Action
Operand Append to end of output expression
Operator ^ Push ^ onto stack
Operator +,-,*, or /
Pop operators from stack, append to output expression until stack empty or top has lower precedence than new operator. Then push new operator onto stack
Open parenthesis
Push ( onto stack
Close parenthesis
Pop operators from stack, append to output expression until we pop an open parenthesis. Discard both parentheses.
30
Transforming Infix to Postfix
Steps to convert the infix expression a / b * ( c + ( d – e ) ) to postfix form.
31
Evaluating Postfix Expression
Fig. 21-10 The stack during the evaluation of the postfix expression a b / when a is 2 and b is 4
32
Evaluating Postfix Expression
Fig. 21-11 The stack during the evaluation of the postfix expression a b + c / when a is 2, b is 4 and c is 3
33
Evaluating Infix Expressions
Two stacks during evaluation of a + b * c when a = 2, b = 3, c = 4; (a) after reaching end of expression;(b) while performing multiplication; (c) while performing the addition
34
Stacks 35
Performance and Limitations
Performance Let n be the number of elements in the stack The space used is O(n) Each operation runs in time O(1)
Limitations The maximum size of the stack must be
defined a priori and cannot be changed Trying to push a new element into a full stack
causes an implementation-specific exception
35
36
QUEUES
Definition: A sequence of elements of the same type.
The first stored element is first accessible.
The structure is known also under the name FIFO - first in first out
37
Basic operations
EnQueue : store a data item at the end of the queue
DeQueue : retrieve a data item from the beginning of the queue
The Queue Interface Queue
Very similar to a stack. Items are inserted in one end (the back)
and removed from the other end (the front). first-in, first-out, or FIFO
38
The Queue Interface39
40
Array Implementation of a Queue
Similar to the linked-list queue, there are two data members called front and back, but they are indexes into an Array instead of pointers
When enqueuing, the back index is incremented, and when dequeuing, the front index is incremented
41
Enqueue / Dequeue
0 1 2 3 4 5 6 7
front back
42
Enqueue / Dequeue (cont.)
front back
DEQUEUE
0 1 2 3 4 5 6 7
43
Enqueue / Dequeue (cont.)
front back
DEQUEUE
0 1 2 3 4 5 6 7
44
Enqueue / Dequeue (cont.)
front back
DEQUEUE
0 1 2 3 4 5 6 7
45
Enqueue / Dequeue (cont.)
front back
DEQUEUE
0 1 2 3 4 5 6 7
46
Enqueue / Dequeue (cont.)
front back
ENQUEUE
0 1 2 3 4 5 6 7
47
Enqueue / Dequeue (cont.)
0 1 2 3 4 5 6 7
front back
ENQUEUE
48
Enqueue / Dequeue (cont.)
0 1 2 3 4 5 6 7
front back
ENQUEUE
49
Enqueue / Dequeue (cont.)
0 1 2 3 4 5 6 7
front back
ENQUEUE
50
0 1 2 3 4 5 6 7
front back
DEQUEUE
Enqueue / Dequeue (cont.)
51
0 1 2 3 4 5 6 7
front back
DEQUEUE
Enqueue / Dequeue (cont.)
52
0 1 2 3 4 5 6 7
front back
DEQUEUE
Enqueue / Dequeue (cont.)
53
0 1 2 3 4 5 6 7
front back
DEQUEUE
Enqueue / Dequeue (cont.)
54
0 1 2 3 4 5 6 7
front back
ENQUEUE
Enqueue / Dequeue (cont.)
55
0 1 2 3 4 5 6 7
front back
ENQUEUE
Enqueue / Dequeue (cont.)
56
0 1 2 3 4 5 6 7
front back
DEQUEUE
Enqueue / Dequeue (cont.)
57
0 1 2 3 4 5 6 7
front back
DEQUEUE
Enqueue / Dequeue (cont.)
58
0 1 2 3 4 5 6 7
front back
DEQUEUE
Enqueue / Dequeue (cont.)
59
0 1 2 3 4 5 6 7
front back
ENQUEUE
Enqueue / Dequeue (cont.)
60
0 1 2 3 4 5 6 7
front back
ENQUEUE
?
Enqueue / Dequeue (cont.)
61
0 1 2 3 4 5 6 7
front back
ENQUEUE We could double the size of the array here.
Enqueue / Dequeue (cont.)
62
0 1 2 3 4 5 6 7
front back
ENQUEUE
But if we keep doing this, we may have a million elements in the Array, but only a few at the end are used!
Enqueue / Dequeue (cont.)
63
0 1 2 3 4 5 6 7
front back
ENQUEUE
We handle this problem by having the back wrap around to the beginning of the array.
Enqueue / Dequeue (cont.)
64
0 1 2 3 4 5 6 7
frontback
ENQUEUE
Enqueue / Dequeue (cont.)
65
0 1 2 3 4 5 6 7
frontback
The front also wraps to the beginning when it reaches the end of the array
Enqueue / Dequeue (cont.)
66
How Do We Know When the Array is Full? We may still need to double the capacity
of the array if it gets filled An array will be full when
back + 1 == front OR back + 1 == capacity AND front == 0
67
A Full Array
0 1 2 3 4 5 6 7
frontback
68
A Full Array
0 1 2 3 4 5 6 7
frontback
If the next operation is ENQUEUE, the array capacity will need to be doubled
69
Implementing Queues with Links
Because a queue is a linear collection, we can implement a queue as a linked list of LinearNode objects, as we did with stacks
One important difference, however, is that we will have to operate on both ends of the list
So we'll add an additional reference variable (rear) that points to the last element in the list
70
Dequeue Operation
front back
header
71
Dequeue Operation (cont.)
front back
header
72
Enqueue Operation
front back
header
73
Enqueue Operation (cont.)
front back
header
Summary Stacks and queues are collections of
objects. Stack follows a last-in, first-out policy.
Objects are pushed onto and popped off the top.
Queue follows a first-in, first-out policy. Objects are added to the back and removed
from the front.
74