Chapter 17:

Stacks and Queues

 Objectives
• In this chapter, you will:
– Learn about stacks
– Examine various stack operations
– Implement a stack as an array
– Implement a stack as a linked list
– Discover stack applications
– Use a stack to remove recursion
– Learn about queues
– Examine various queue operations
– Implement a queue as an array
– Implement a queue as a linked list
– Discover queue applications

C++ Programming: Program Design Including Data Structures, Sixth Edition 2

 Stacks
• Stack: a data structure in which elements are added
and removed from one end only
– Addition/deletion occur only at the top of the stack
– Last in first out (LIFO) data structure
• Operations:
– Push: to add an element onto the stack
– Pop: to remove an element from the stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 3

 Stacks (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 4

 Stacks (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 5

 Stacks (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 6

 Stack Operations
• In the abstract class stackADT:
– initializeStack
– isEmptyStack
– isFullStack
– push
– top
– pop

C++ Programming: Program Design Including Data Structures, Sixth Edition 7

 Implementation of Stacks
as Arrays
• First element goes in first array position, second in
the second position, etc.
• Top of the stack is index of the last element added to
the stack
• Stack elements are stored in an array, which is a
random access data structure
– Stack element is accessed only through top
• To track the top position, use a variable called
stackTop

C++ Programming: Program Design Including Data Structures, Sixth Edition 8

 Implementation of Stacks as Arrays
(cont’d.)
• Can dynamically allocate array
– Enables user to specify size of the array
• class stackType implements the functions of
the abstract class stackADT

C++ Programming: Program Design Including Data Structures, Sixth Edition 9

 Implementation of Stacks as Arrays
(cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 10

 Implementation of Stacks as Arrays
(cont’d.)
• C++ arrays begin with the index 0
– Must distinguish between:
• Value of stackTop
• Array position indicated by stackTop
• If stackTop is 0, stack is empty
• If stackTop is nonzero, stack is not empty
– Top element is given by stackTop - 1

C++ Programming: Program Design Including Data Structures, Sixth Edition 11

 Implementation of Stacks as Arrays
(cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 12

 Initialize Stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 13

 Empty Stack/Full Stack
• Stack is empty if stackTop = 0

• Stack is full if stackTop = maxStackSize

C++ Programming: Program Design Including Data Structures, Sixth Edition 14

 Push
• Store the newItem in the array component
indicated by stackTop
• Increment stackTop
• Overflow occurs if we try to add a new item to a full
stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 15

 Push (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 16

 Push (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 17

 Return the Top Element
• top operation:
– Returns the top element of the stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 18

 Pop
• To remove an element from the stack, decrement
stackTop by 1
• Underflow condition: trying to remove an item from
an empty stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 19

 Pop (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 20

 Pop (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 21

 Copy Stack
• copyStack function: copies a stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 22

 Constructor and Destructor
• Constructor:
– Sets stack size to parameter value (or default value if not
specified)
– Sets stackTop to 0
– Creates array to store stack elements
• Destructor:
– Deallocates memory occupied by the array
– Sets stackTop to 0

C++ Programming: Program Design Including Data Structures, Sixth Edition 23

 Copy Constructor
• Copy constructor:
– Called when a stack object is passed as a (value) parameter
to a function
– Copies values of member variables from actual parameter
to formal parameter

C++ Programming: Program Design Including Data Structures, Sixth Edition 24

 Overloading the
Assignment Operator (=)
• Assignment operator must be explicitly overloaded
because of pointer member variables

C++ Programming: Program Design Including Data Structures, Sixth Edition 25

 Stack Header File
• Place definitions of class and functions (stack
operations) together in a file
– Called myStack.h

C++ Programming: Program Design Including Data Structures, Sixth Edition 26

 Linked Implementation of Stacks
• Array only allows fixed number of elements
• If number of elements to be pushed exceeds array
size, the program may terminate
• Linked lists can dynamically organize data
• In a linked representation, stackTop is pointer to
memory address of top element in stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 27

 Linked Implementation of Stacks
(cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 28

 Default Constructor
• Initializes the stack to an empty state when a stack
object is declared
– Sets stackTop to NULL

C++ Programming: Program Design Including Data Structures, Sixth Edition 29

 Empty Stack and Full Stack
• In a linked implementation of stacks, function
isFullStack does not apply
– Logically, the stack is never full
• Stack is empty if stackTop is NULL

C++ Programming: Program Design Including Data Structures, Sixth Edition 30

 Initialize Stack
• initializeStack: reinitializes stack to an empty
state
– Must deallocate memory occupied by current element
– Sets stackTop to NULL

C++ Programming: Program Design Including Data Structures, Sixth Edition 31

 Push
• newNode is added at the beginning of the linked list
pointed to by stackTop

C++ Programming: Program Design Including Data Structures, Sixth Edition 32

 Push (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 33

 Return the Top Element
• top operation: returns top element of stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 34

 Pop
• Node pointed to by stackTop is removed
– Second element becomes top element

C++ Programming: Program Design Including Data Structures, Sixth Edition 35

 Pop (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 36

 Copy Stack
• copyStack function: makes an identical copy of a
stack
– Similar definition to copyList for linked lists

C++ Programming: Program Design Including Data Structures, Sixth Edition 37

 Constructors and Destructors
• Copy constructor and destructor:
– Similar to those for linked lists

C++ Programming: Program Design Including Data Structures, Sixth Edition 38

 Overloading the Assignment
Operator (=)
• Overloading the assignment operator:

C++ Programming: Program Design Including Data Structures, Sixth Edition 39

 Stack as Derived from the class
unorderedLinkedList
• Implementation of push is similar to
insertFirst for general lists
• Other similar functions:
– initializeStack and initializeList
– isEmptyList and isEmptyStack
• linkedStackType can be derived from
linkedListType
– class linkedListType is abstract

C++ Programming: Program Design Including Data Structures, Sixth Edition 40

 Derived Stack (cont’d.)
• unorderedLinkedListType is derived from
linkedListType
– Provides the definitions of the abstract functions of the
class linkedListType
• and derive linkedStackType from
unorderedLinkedListType

C++ Programming: Program Design Including Data Structures, Sixth Edition 41

 Application of Stacks: Postfix
Expressions Calculator
• Infix notation: usual notation for writing arithmetic
expressions
– Operator is written between the operands
– Example: a + b
– Evaluates from left to right
– Operators have precedence
• Parentheses can be used to override precedence

C++ Programming: Program Design Including Data Structures, Sixth Edition 42

 Application of Stacks: Postfix
Expressions Calculator (cont’d.)
• Prefix (Polish) notation: operators are written before
the operands
– Introduced by the Polish mathematician Jan Lukasiewicz in
early 1920s
– Parentheses can be omitted
– Example: + a b

C++ Programming: Program Design Including Data Structures, Sixth Edition 43

 Application of Stacks: Postfix
Expressions Calculator (cont’d.)
• Reverse Polish notation: operators follow the
operands (postfix operators)
– Proposed by Australian philosopher and early computer
scientist Charles L. Hamblin in the late 1950s
– Advantage: operators appear in the order required for
computation
– Example: a + b * c becomes a b c * +

C++ Programming: Program Design Including Data Structures, Sixth Edition 44

 Application of Stacks: Postfix
Expressions Calculator (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 45

 Application of Stacks: Postfix
Expressions Calculator (cont’d.)
• Postfix notation has important applications in
computer science
– Many compilers first translate arithmetic expressions into
postfix notation and then translate this expression into
machine code
• Evaluation algorithm:
– Scan expression from left to right
– When an operator is found, back up to get operands,
perform the operation, and continue

C++ Programming: Program Design Including Data Structures, Sixth Edition 46

 Application of Stacks: Postfix
Expressions Calculator (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 47

 Application of Stacks: Postfix
Expressions Calculator (cont’d.)
• Symbols can be numbers or anything else:
– +, -, *, and / are operators, require two operands
• Pop stack twice and evaluate expression
• If stack has less than two elements  error
– If symbol is =, expression ends
• Pop and print answer from stack
• If stack has more than one element  error
– If symbol is anything else
• Expression contains an illegal operator

C++ Programming: Program Design Including Data Structures, Sixth Edition 48

 Application of Stacks: Postfix
Expressions Calculator (cont’d.)
• Assume postfix expressions are in this form:
#6 #3 + #2 * =
– If symbol scanned is #, next input is a number
– If the symbol scanned is not #, then it is:
• An operator (may be illegal) or
• An equal sign (end of expression)
• Assume expressions contain only +, -, *, and /
operators

C++ Programming: Program Design Including Data Structures, Sixth Edition 49

 Main Algorithm
• Pseudocode:

• Four functions are needed:

– evaluateExpression, evaluateOpr,
discardExp, and printResult

C++ Programming: Program Design Including Data Structures, Sixth Edition 50

 Function
evaluateExpression
• Function evaluateExpression:
– Evaluates each postfix expression
– Each expression ends with = symbol

C++ Programming: Program Design Including Data Structures, Sixth Edition 51

 Function evaluateOpr
• Function evaluateOpr:
– Evaluates an expression
– Needs two operands saved in the stack
• If less than two  error
– Also checks for illegal operations

C++ Programming: Program Design Including Data Structures, Sixth Edition 52

 Function discardExp
• Function discardExp:
– Called when an error is discovered in expression
– Reads and writes input data until the ‘=’

C++ Programming: Program Design Including Data Structures, Sixth Edition 53

 Function printResult
• The function printResult: If the postfix
expression contains no errors, it prints the result
– Otherwise, it outputs an appropriate message
• Result of the expression is in the stack, and output is
sent to a file

C++ Programming: Program Design Including Data Structures, Sixth Edition 54

 Nonrecursive Algorithm to Print a
Linked List Backward
• To print a list backward nonrecursively, first get to the
last node of the list
– Problem: Links go in only one direction
– Solution: Save a pointer to each of node in a stack
• Uses the LIFO principle
• Since number of nodes is usually not known, use the
linked implementation of a stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 55

 Nonrecursive Algorithm to Print a
Linked List Backward (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 56

 Nonrecursive Algorithm to Print a
Linked List Backward (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 57

 Nonrecursive Algorithm to Print a
Linked List Backward (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 58

 Nonrecursive Algorithm to Print a
Linked List Backward (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 59

 Nonrecursive Algorithm to Print a
Linked List Backward (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 60

 Nonrecursive Algorithm to Print a
Linked List Backward (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 61

 Queues
• Queue: set of elements of the same type
• Elements are:
– Added at one end (the back or rear)
– Deleted from the other end (the front)
• First In First Out (FIFO) data structure
– Middle elements are inaccessible
• Example:
– Waiting line in a bank

C++ Programming: Program Design Including Data Structures, Sixth Edition 62

 Queue Operations
• Queue operations include:
– initializeQueue
– isEmptyQueue
– isFullQueue
– front
– back
– addQueue
– deleteQueue
• Abstract class queueADT defines these
operations

C++ Programming: Program Design Including Data Structures, Sixth Edition 63

 Implementation of Queues as
Arrays
• Need at least four (member) variables:
– Array to store queue elements
– queueFront and queueRear
• To track first and last elements
– maxQueueSize
• To specify maximum size of the queue

C++ Programming: Program Design Including Data Structures, Sixth Edition 64

 Implementation of Queues as
Arrays (cont’d.)
• To add an element to the queue:
– Advance queueRear to next array position
– Add element to position pointed by queueRear

C++ Programming: Program Design Including Data Structures, Sixth Edition 65

 Implementation of Queues as
Arrays (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 66

 Implementation of Queues as
Arrays (cont’d.)
• To delete an element from the queue:
– Retrieve element pointed to by queueFront
– Advance queueFront to next queue element

C++ Programming: Program Design Including Data Structures, Sixth Edition 67

 Implementation of Queues as
Arrays (cont’d.)
• Will this queue design work?
– Let A represent adding an element to the queue
– Let D represent deleting an element from the queue
– Consider the following sequence of operations:
• AAADADADADADADADA...

C++ Programming: Program Design Including Data Structures, Sixth Edition 68

 Implementation of Queues as
Arrays (cont’d.)
• This would eventually set queueRear to point to
the last array position
– Giving the impression that the queue is full

C++ Programming: Program Design Including Data Structures, Sixth Edition 69

 Implementation of Queues as
Arrays (cont’d.)
• Solution 1: When queue overflows at rear
(queueRear points to the last array position):
– Check value of queueFront
– If queueFront indicates there is room at front of array,
slide all queue elements toward the first array position
• Problem: too slow for large queues
• Solution 2: Assume that the array is circular

C++ Programming: Program Design Including Data Structures, Sixth Edition 70

 Implementation of Queues as
Arrays (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 71

 Implementation of Queues as
Arrays (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 72

 Implementation of Queues as
Arrays (cont’d.)
• Deletion Case 1:

C++ Programming: Program Design Including Data Structures, Sixth Edition 73

 Implementation of Queues as
Arrays (cont’d.)
• Deletion Case 2:

C++ Programming: Program Design Including Data Structures, Sixth Edition 74

 Implementation of Queues as
Arrays (cont’d.)
• Problem:
– Figures 18-32b and 18-33b have identical values for
queueFront and queueRear
– However, Figure 18-32b represents an empty queue,
whereas Figures 18-33b shows a full queue
• Solution?

C++ Programming: Program Design Including Data Structures, Sixth Edition 75

 Implementation of Queues as
Arrays (cont’d.)
• Solution 1: keep a count
– Incremented when a new element is added to the queue
– Decremented when an element is removed
– Initially set to 0
– Very useful if user (of queue) frequently needs to know the
number of elements in the queue

C++ Programming: Program Design Including Data Structures, Sixth Edition 76

 Implementation of Queues as
Arrays (cont’d.)
• Solution 2: Let queueFront indicate index of array
position preceding the first element
– queueRear still indicates index of last one
– Queue empty if:
• queueFront == queueRear
– Slot indicated by queueFront is reserved
– Queue is full if next available space is the reserved slot
indicated by queueFront

C++ Programming: Program Design Including Data Structures, Sixth Edition 77

 Implementation of Queues as
Arrays (cont’d.)

C++ Programming: Program Design Including Data Structures, Sixth Edition 78

 Empty Queue and Full Queue
• Queue is empty if count ==0
• Queue is full if count == maxQueueSize

C++ Programming: Program Design Including Data Structures, Sixth Edition 79

 Initialize Queue
• Initializes queue to empty state
– First element is added at first array position
– queueFront set to 0
– queueRear set to maxQueueSize -1
– count set to 0

C++ Programming: Program Design Including Data Structures, Sixth Edition 80

 Front and Back
• front operation: returns the first element of the
queue
– If queue is empty, program terminates
• back operation: returns the last element of the
queue
– If queue is empty, program terminates

C++ Programming: Program Design Including Data Structures, Sixth Edition 81

 addQueue
• addQueue operation:
– Advance queueRear to next array position
– Add new element to array position indicated by
queueRear
– Increment count by 1

C++ Programming: Program Design Including Data Structures, Sixth Edition 82

 deleteQueue
• deleteQueue operation:
– Decrement count by 1
– Advance queueFront to next queue element

C++ Programming: Program Design Including Data Structures, Sixth Edition 83

 Constructors and Destructors
• Constructor:
– Sets maxQueueSize to user specification
– Creates array of size maxQueueSize (or default size)
– Initializes queueFront and queueRear to indicate
empty queue
• Destructor:
– Deallocates memory occupied by array

C++ Programming: Program Design Including Data Structures, Sixth Edition 84

 Linked Implementation of Queues
• Array implementation has issues:
– Array size is fixed: only a finite number of queue elements
can be stored in it
– Requires array to be treated in a special way, together with
queueFront and queueRear
• Linked implementation of a queue simplifies many
issues
– Queue is never full because memory is allocated
dynamically

C++ Programming: Program Design Including Data Structures, Sixth Edition 85

 Linked Implementation of Queues
(cont’d.)
• Elements are added at one end and removed from
the other
– Need only two pointers to maintain the queue:
queueFront and queueRear

C++ Programming: Program Design Including Data Structures, Sixth Edition 86

 Empty and Full Queue
• Queue is empty if queueFront is NULL
• Queue is never full
– Unless the system runs out of memory
• Note: must provide isFullQueue function
definition because it is an abstract function in parent
class queueADT

C++ Programming: Program Design Including Data Structures, Sixth Edition 87

 Initialize Queue
• Initializes queue to an empty state
– Must remove all existing elements, if any
– Deallocates memory occupied by elements

C++ Programming: Program Design Including Data Structures, Sixth Edition 88

 addQueue, front, back, and
deleteQueue operations
• addQueue operation: adds new element to end of
queue
• front operation: returns first element of queue
• back operation: returns last element of queue
• deleteQueue operation: removes first element of
queue

C++ Programming: Program Design Including Data Structures, Sixth Edition 89

Constructors and Destructors
• Constructor
– Accesses maxQueueSize, queueFront, and
queueRear
• Destructor: destroys the queue
– Deallocates memory occupied by elements
• Copy constructor and overloading assignment
operator:
– Similar to corresponding function for stack

C++ Programming: Program Design Including Data Structures, Sixth Edition 90

 Queue Derived from the class
unorderedLinkedListType
• Linked implementation of queue: similar to
implementation of a linked list created in a forward
manner
– addQueue similar to insertFirst
– initializeQueue is like initializeList
– isEmptyQueue similar to isEmptyList
– deleteQueue can be implemented as before
– queueFront is same as first
– queueRear is same as last

C++ Programming: Program Design Including Data Structures, Sixth Edition 91

 Application of Queues: Simulation
• Simulation: a technique in which one system models
the behavior of another system
• Computer models are used to study the behavior of
real systems
• Queuing systems: computer simulations using
queues as the data structure
– Queues of objects are waiting to be served

C++ Programming: Program Design Including Data Structures, Sixth Edition 92

 Designing a Queuing System
• Server: object that provides the service
• Customer: object receiving the service
• Transaction time: service time, or the time it takes to
serve a customer
• Model: system that consists of a list of servers and a
waiting queue holding the customers to be served
– Customer at front of queue waits for the next available
server

C++ Programming: Program Design Including Data Structures, Sixth Edition 93

 Designing a Queuing System
(cont’d.)
• Need to know:
– Number of servers
– Expected arrival time of a customer
– Time between the arrivals of customers
– Number of events affecting the system
• Performance of system depends on:
– How many servers are available
– How long it takes to serve a customer
– How often a customer arrives

C++ Programming: Program Design Including Data Structures, Sixth Edition 94

 Designing a Queuing System
(cont’d.)
• If it takes too long to serve a customer and
customers arrive frequently, then more servers are
needed
– System can be modeled as a time-driven simulation
• Time-driven simulation: the clock is a counter
– The passage of one unit of time can be implemented by
incrementing a counter by 1
– Simulation is run for a fixed amount of time

C++ Programming: Program Design Including Data Structures, Sixth Edition 95

 Customer

C++ Programming: Program Design Including Data Structures, Sixth Edition 96

 Server

C++ Programming: Program Design Including Data Structures, Sixth Edition 97

 Server List
• Server list: a set of servers
– At any given time, a server is either free or busy

C++ Programming: Program Design Including Data Structures, Sixth Edition 98

 Waiting Customers Queue
• When customer arrives, he/she goes to end of queue
• When a server becomes available, customer at front
of queue leaves to conduct the transaction
• After each time unit, the waiting time of each
customer in the queue is incremented by 1
• Can use queueType but must add an operation to
increment waiting time

C++ Programming: Program Design Including Data Structures, Sixth Edition 99

 Main Program
• Algorithm for main loop:

C++ Programming: Program Design Including Data Structures, Sixth Edition 100
 Summary
• Stack: items are added/deleted from one end
– Last In First Out (LIFO) data structure
– Operations: push, pop, initialize, destroy, check for
empty/full stack
– Can be implemented as array or linked list
– Middle elements should not be accessed directly
• Postfix notation: operators are written after the
operands (no parentheses needed)

C++ Programming: Program Design Including Data Structures, Sixth Edition 101
 Summary (cont’d.)
• Queue: items are added at one end and removed
from the other end
– First In First Out (FIFO) data structure
– Operations: add, remove, initialize, destroy, check if queue
is empty/full
– Can be implemented as array or linked list
– Middle elements should not be accessed directly
– Is a restricted version of array and linked list

C++ Programming: Program Design Including Data Structures, Sixth Edition 102