Chapter 16 Stack and

Queues part2
Dr. Bernard Chen Ph.D.
University of Central Arkansas

Introduction to Queues

A queue is a waiting line

Its in daily life:

A line of persons waiting to check out at a

supermarket
A line of persons waiting to purchase a ticket
for a film
A line of planes waiting to take off at an airport
A line of vehicles at a toll booth

Introduction to Queues

Difference between Stack and

Queues:

Stack exhibits last-in-first-out (LIFO)

Queue exhibits first-in-first-out (FIFO)

ADT in Queues

Unlike stacks in which elements are

popped and pushed only at the ends of
the list,

Collection of data elements:

items are removed from a queue at one
end, called the FRONT of the queue;
and elements are added at the other end,
called the BACK

Queue ADT

Basic operations

Construct a queue
Check if empty
Enqueue (add element to back)
Front (retrieve value of element from
front)
Dequeue (remove element from front)

Designing and Building a

Queue Class Array-Based

Consider an array in which to store a

queue

Note additional variables needed

myFront, myBack
Picture a queue
object like this

Queue Operation

Empty Queue

Enqueue(70)

Queue Operation

Enqueue(80)

Enqueue(50)

Queue Operation

Dequeue()

Dequeue()

Queue Operation

Enqueue(90)

Enqueue(60)

Circular Queue

Problems

We quickly "walk off the end" of the array

Possible solutions

Shift array elements

Use a circular queue
Note that both empty
and full queue
gives myBack == myFront

Circular Queue

Using a static array

QUEUE_CAPACITY specified

Enqueue increments myBack using

mod operator, checks for full queue

Dequeue increments myFront using

mod operator, checks for empty
queue

Circular Example

Both Front and Back wraparound

as needed.
b
Back

Front

b
Back

Front

QUEUE

Only tricky part is vector doubling because

the queue items are not necessarily stored
in an array starting at location 0, and the
contiguity of wraparound must be
maintained.

Therefore, mostly straightforward;

maintain
Front
Back

Queue Full Situation

If an item were stored in the last position, and an

Enqueure() occurred

myBack would be incremented by 1, giving it the same

value as myFront
However, myFront == myBack indicates the queue is
empty
Thus, we cannot distinguish between empty and full

We may avoid this situation by maintaining one empty

position, so that myFront will never equal to myBack
unless the queue is empty

Queue Operation

Construct:
Create an array, set capacity,
myFront=myBack=0

Empty:
test myFront==myBack

Front :
if not empty:
print array[myFront]

Algorithm for
Enqueue(value)

1. Set newBack ==
(myBack+1)%Queue_capacity

2. If newBack == myFront
Signal Queue Full
otherwise:
Set Array[myBack] == value
Set myBack == newBack

Algorithm for Dequeue()

If queue is empty
signal Queue Empty
Otherwise
Set
myFront=(myFront+1)%Queue_capacity

Linked Queues

We could also use linked list to store

queue elements
Can grow and shrink to fit the
situation
No need for upper bound
(myCapacity)

Linked Queues

Constructor initializes
myFront, myBack

Empty
myFront == Null

Front
return myFront->data

Dequeue
Delete first node (watch for empty queue)

Enqueue
Insert node at end of list

Enqueue
newptr= new Node(value)
if (empty())
myFront=myBack=newptr;

else
{
myBack->next=newptr;
myBack=newwptr;
}

Dequeue
(if not empty)
ptr=myFront
myFront=myFront->next
delete ptr;

Queue ADT implement by

Vectors

Basic operations

Construct a queue
Check if empty
Enqueue (add element to back)
Front (retrieve value of element from
front)
Dequeue (remove element from front)

Enqueue and Front

Enqueue (add element to back)

This is the same with push(), therefore:

L.push_back(value);
Front (retrieve value of element from front)

L.begin();

Dequeue

Dequeue (remove element from

front)

L.erase( L.begin() );

L.begin() is an iterator, in erase(),

you cannot just gives the location

Functions related to Queue

Constructor: vector<int> L;
Empty():
L.size() == 0?
Enqueue():
L.push_back(value);
Front():
L.begin();
Dequeue():
L.erase(L.begin());

QUEUE

Write a queue program

Vector Functions

Queue + Stack

SCROLL: a queue-stack hybrid model

Thus, you may have functions in both

Push(value)=Enqueue(value)
Pop(); Top() --- top of stack
Dequeue(); Front()