Queues. Chapter Objectives 1.Understanding and applying the Queue ADT. 2.Implementing a Queue using...

Queues

Chapter Objectives

1. Understanding and applying the Queue ADT.

2. Implementing a Queue using an array and links.

3. Designing and programming simple simulations.

Real world examples

Cars in line at a tool booth

People waiting in line for a movie

Computer world examples

Jobs waiting ot be executed

Jobs waiting to be printed

Input buffersCharacters waiting to be processed

Common queue properties

Queues have the poperty that, the earlier an item enters a queue, the earlier it will leave the queue:

First in, first out (FIFO)

Queues and lists

A queue is a restricted form of a list.

Additions to the queue must occur a the rear.

Deletions from the queue must occur at the front

Example

Rear item is most recent addition to queue

Front item has waited Longer than all other queue entries

Items enter at rear and leave at front

Problem:

Computer network performance Author’s example: ethernet Ethernet is a set of protocols describing

how devices on a network can communicate

A sample Ethernet configuration

1 3 5 7

File Server Workstation Workstation Bridge

PrinterPCPC

How ethernet works

Devices place messages onto the network preceded by the id number of the device the message is intended for.

If two devices send messages at the same time a collision occurs.

Device communication

Devices operate at differing speeds PC may place document on network at 100,000

cps Ethernet transmits document at 1,250,000 cps Printer may only processes 10,000 cps

How does the printer handle the pileup of characters sent by the PC?

Print buffers

A buffer is a queue Incoming data is stored at the rear It processes data in a FIFO manner

Operation of an ethernet buffer

b c 1 2 3 x y z 0

Ethernet

Printer

next character goes here

Queue ADTCharacteristics

• A Queue Q stores items of some type (queueElementType), with First-In, First-Out (FIFO) access.

Operations

queueElementType A.dequeue()

Precondition: !isEmpty()

Postcondition: Qpost = Qpre with front removed

Returns: The least-recently enqueued item (the front).

Queue ADT operations (continued)void Q.enqueue(queueElementType x)

Precondition: None

Postcondition: Qpost = Qpre with x added to the rear.

queueElementType Q.front()

Precondition: !isEmpty()

Postcondition: None

Returns: The least-recently enqueued item

(the front).

bool Q.isEmpty()

Precondition: None

Postcondition: None

Returns: true if and only if Q is empty,

i.e., contains no data items.

Code Example

int main()

char c;

Queue < char > q;

Stack < char > s;

Code Example (continued)// read characters until '.' found, adding each to Q and S.

while (1) {

cin >> c;

if (c == '.') break; // when '.' entered, leave the loop

q.enqueue(c);

s.push(c);

while (!q.isEmpty()) {

cout << "Q: " << q.dequeue() << '\t';

cout << "S: " << s.pop() << '\n';

return 0;

Sample program output

Q: a S: c Q: b S: b Q: c S: a Queues preserve order while stacks reverse

Exercise 9-1What is the output resulting from the following sequence, where q is an initially empty queue of int:

q.enqueue(1);

q.enqueue(2); // different than text

q.enqueue(3);

cout << q.front();

cout << q.dequeue();

cout << q.front();

if (q.isEmpty())

cout << “empty\n”;

cout << “not empty\n”;

program analysis

q.enqueue(1)

q.enqueue(3)

Program output

frontrear

cout << q.front();

cout << q.dequeue();

cout << q.front();

frontrear

Program continued

frontrear

if (q.isEmpty()) cout << “empty” << endl;else cout << “not empty” << endl;

not empty

Array implementation

Must keep track of front and rear (more complicated than a stack)

Rear and front

With data in a queue, implemented as an array, rear will normally be greater than front.

There are 3 special situations which must be addressed

1. Rear < front (empty queue) 2. Rear = front (one-entry queue) 3. Rear = array size (full queue)

Example: enqueueingEmpty queue

Front Front

Rear Rear

Single elementqueue

Normalqueue

Various queue states

Normalqueue

Fullqueue

dequeueing

FrontRear

Moredequeueing

Single element queue

A problem

We cannot increase rear beyondthe limits of the array.Therefore, this queue must beregarded as full, even though thereare plenty of available memory cells.

One way to solve this might be toWait until the queue empties out andThen reset it and start again.

In the computer processing job examplehowever, this would be unacceptablesince many jobs could arrive while thequeue is emptying out.

Another difficultly

Is the queueempty or full?

Our definition ofempty is rear < front, so it is empty.

But, rear has reachedits limit. It cannot gobeyond the array, Therefore, the queue is full!

The solution: wrapping around

Next enqueuewraps around

The circular queue

Circularqueue Rear

emptyemptyemptyempty

Author’s example

Example: Queue is an array of 4 elements We wish to enqueue and dequeue multiple

enqueue and dequeue operations

a ? ? ?

a b c ?

a b c d

enqueue('a')

enqueue('b')

enqueue('c')

dequeue()

enqueue('d')

dequeue()

enqueue('e') ? ? ? ?

A paradox

With an array, it is easy to run out of space in the queue to enqueue items and yet still have unused memory cells that can store data!

To get around this, we have to make it possible to ‘wrap around’

Both ‘rear’ and ‘front’ must be able to wrap around.

How to wrap around

If rear + 1 > maxQueue -1 then set rear to 0 OR rear = (rear+1) % maxQueue

A Circular Queue

Main issues (full and empty)

Wrapping around allows us to avoid an erroneous ‘full’

But, it means that we cannot use ‘rear < front’ as a test of whether the queue is empty because rear will become < front as soon as it wraps around

Rear and front If there is one element in the queue then

rear should be the same as front, therefore, rear must start < front.

You could check for an empty queue with something like: nextPos(rear) == front

But, when the queue is full it is also true that nextPos(rear) == front!

Queue implementation in which full and empty queues cannot be distinguished

Solution

To solve this dilemma we let the definition of empty be rear==front

Where front points to an empty cell (like the header node on linked lists).

Then the test for empty is rear==front And the test for full is nextPos(rear) ==

Corrected queue implementation demonstrated

Alternate queue implementations(poor vs. good design)

Explanation using conventional arrays

Empty queue ((rear + 1) == front)

Wrapped around

Full queue((rear+1) == front)

Solution

Empty queue (rear == front)

Wrapped around

Full queue((rear+1) == front)

Queue template

const int maxQueue = 200;

template < class queueElementType >

class Queue {

public:

Queue();

void enqueue(queueElementType e);

queueElementType dequeue();

queueElementType front();

bool isEmpty();

private:

int f; // marks the front of the queue

int r; // marks the rear of the queue

queueElementType elements[maxQueue];

NextPos(), does the wrap around

int nextPos(int p)

if (p == maxQueue - 1) // at end of circle

return 0;

return p+1;

Constructor

Queue < queueElementType >::Queue()

{ // start both front and rear at 0

f = 0;

r = 0;

enqueue()

Queue < queueElementType > :: enqueue(queueElementType e)

{ // add e to the rear of the queue, // advancing r to next position

assert(nextPos(r) != f);

r = nextPos(r);

elements[r] = e;

Dequeue()

queueElementType

Queue < queueElementType >::dequeue()

// advance front of queue, // return value of element at the front

assert(f != r);

f = nextPos(f);

return elements[f];

front()

queueElementType

Queue < queueElementType >::front()

// return value of element at the front

assert(f != r);

return elements[nextPos(f)];

isEmpty()

Queue < queueElementType >::isEmpty()

// return true if the queue is empty, that is,

// if front is the same as rear

return bool(f == r);

Dynamic queues The advantages of linked list

implementation are The size is limited only by the pool of available

nodes (the heap) There is no need to wrap around anything.

Advantage of using the heap No need for program to check for a full queue

(this is handled by the ‘new’ function.

Header for queue as dynamic list

class Queue {

public:

Queue();

void enqueue(queueElementType e);

queueElementType dequeue();

queueElementType front();

bool isEmpty();

Private section

private:

struct Node;

typedef Node * nodePtr;

struct Node {

queueElementType data;

nodePtr next;

nodePtr f;

nodePtr r;

Implementation file, constructor

Queue < queueElementType >::Queue()

// set both front and rear to null pointers

f = 0;

r = 0;

enqueue()template < class queueElementType >

void Queue < queueElementType > ::enqueue(queueElementType e)

{// create a new node, insert it at the rear of the queue

nodePtr n(new Node);

assert(n);

n->next = 0;

n->data = e;

if (f != 0) { // existing queue is not empty

r->next = n; // add new element to end of list

r = n;

} else {// adding first item in the queue

f = n; // so front, rear must be same node

r = n;

A single-element queue

A single element queueFront == rear

enqueueing

Rear n

dequeue()

queueElementType

Queue < queueElementType >::dequeue()

{ assert(f); // make sure queue is not empty

nodePtr n(f);

queueElementType frontElement(f->data);

f = f->next;

delete n;

if (f == 0) // we're deleting last node

r = 0;

return frontElement;

dequeueing

nRearFront

RearFront

front()

queueElementType

Queue < queueElementType >::front()

assert(f);

return f->data;

isEmpty()

Queue < queueElementType >::isEmpty()

// true if the queue is empty -- when f is a null pointer

return bool(f == 0);

Simulation

Modeling a computer network Each device is connected to the network by

a ‘controller’ Before a controller sends a message it

checks to see if the network is busy. If so, it waits. If not, it sends the message.

Collisions

When two controllers attempt to send a message at the same time the messages collide and the receiving controllers ignore it.

Similarly, the sending controllers recognize the problem and resend their messages.

Queues

Queues are needed to collect data. The sending controllers need them because

they must have the capability of storing data until the network is not busy.

Receiving controllers need queues because they cannot process data as fast as the network can send it.

Device-controller interface

device queue controller

Ethernet

Network collision rates One measure of a network is its ‘effective

bandwidth ratio’ This is the ratio of the amount of data

actually transmitted and the maximum possible data the network can transmit.

A network that sends data one quarter of the time has a bandwidth ratio of .25

Bandwidth and collisions

As the number of messages sent on the network goes up, so does the bandwidth ratio - to a point

When too many collisions occur the bandwidth ratio may go down because messages are being garbled and hence ignored.

Ethernet simulation

int main()

{ randomize(); // provide seed to random generator

int steps;

cerr << "Enter number of steps: ";

cin >> steps;

int maxCnts;

cerr << "Enter max number of controllers: ";

cin >> maxCnts;

int cnts;

for (cnts = 10; cnts <= maxCnts; cnts+=10) // increase by 10 each pass

Controller * ctrl[1000];

int i;

for (i=0; i < cnts; i++) // more controllers created each pass

ctrl[i] = new Controller;

Code Example 9-6

long int collisions(0), transmissions(0);

int p;

for (p = 0; p < steps; p++) {

int senders(0);

int netChar(netQuiet);

int c;

for (c = 0; c < cnts; c++) {

int ch(ctrl[c]->phase1()); // get message, if any, from device

if (ch != 0) {

senders++;

netChar = ch;

Code Example 9-6 if (senders > 1) {

netChar = netCollide;

collisions++; // count collisions

else if (senders == 1)

transmissions++; // count successful transmissions

for (c = 0; c < cnts; c++)

ctrl[c]->phase2(netChar);

cout << "---\nControllers: " << cnts << "\n";

cout << "Collision count: " << collisions << "\n";

cout << "Transmission count: " << transmissions << endl;

for (i = 0; i < cnts; i++)

delete ctrl[i];

} return 0;

Controller class

enum { netQuiet = 0, netCollide = -100 };

const long maxWait = 20;

class Controller {

public:

Controller();

int phase1(); // update the device and check its state

void phase2(int netchar); // receive network contents

private:

enum state { Idle, Listen, Wait, Send };

int currentState;

Queue < char > outQ;

Device dev;

int waitTime;

Controller State Machine

Each step begins with one of these four states: idle, listen, wait or send

Depending on the result of the phase1 call and the contents of the controller queue, the device may stay in the same state or move to a new one.

State diagram for network controller

netColli

inchar

endMessage

waitTime==0

!netQuiet

LISTEN SEND

netQuietendMessage

Controller constructor

Controller::Controller()

currentState = Idle;

Phase I : update and check device

int Controller::phase1()

int inchar(dev.update()); // update device

int outchar(0);

if (inchar)

outQ.enqueue(inchar); // put character in controller queue

switch(currentState) {

case Idle:

if (inchar)

currentState = Listen;

break;

Phase I, continued

case Listen:

case Wait:

break;

case Send:

if (outQ.isEmpty())

outchar = outQ.front();

break;

return outchar;

Phase II: listen to networkvoid Controller::phase2(int netchar)

int outchar;

switch(currentState) {

case Idle:

break;

case Listen:

if (netchar == netQuiet)

currentState = Send;

else {

waitTime = random(maxWait) + 1;

currentState = Wait;

break;

Phase II, continued

case Wait:

if (waitTime > 0)

waitTime--;

currentState = Listen;

break;

case Send:

if (netchar == netCollide) {

Phase II, continued else {

outchar = outQ.dequeue();

if (outchar == endMessage)

if (outQ.isEmpty())

else {

break;

The Device Classconst int avDelay = 5000;

const int maxMsg = 10;

const int endMessage = -1;

class Device {

public:

Device();

int update();

private:

enum state { Idle, Sending };

state currentState;

int messageLength;

Device constructor

Device::Device()

update() device sending int Device::update() {

int outChar(0);

// if we're sending, put a character out to the controller

if (currentState == Sending) {

if (messageLength--)

outChar = messageLength + 32; // convert number to printable digit

else {

outChar = -1;}

Update() device not sending

// if not, pick random number to decide whether to start sending

else // currentState == Idle

if (random(avDelay) == 0) {

messageLength = random(maxMsg) + 1;

currentState = Sending;

return outChar;

Sample data from network simulation

transmissions

collisions

100 200 300 400 500

Number of Controllers

Priority queues

Queues are often prioritized Example, UMD registration queue

Priority 1: Seniors Priority 2: Juniors Priority 3: Sophomores Priority 4: Freshmen

Other priority queues

Operating systems often prioritize their print queues so that large output does not monopolize the printer during peak times.

Example Priority 1: 5 pages or less Priority 2: 6-30 pages Priority 3: >30 pages

Pointers with priority queues

If you have three priorities (see last example) you would need three rear pointers

Priority print queueFront

Rear 1 (5 pages or less)

Rear 2 (6-30 pages)

Rear 3 (> 30 pages)

statssim

copybank

checkupdateaverag

Processing a new job

Rear 2 (6-30 pages)

Rear 3 (> 30 pages)

statssim

copybank

checkupdateaverag

If a new job called ‘prob1’was sent to the printer andrequired 25 pages to beprinted, it would beplaced at the rear of thesecond priority (Rear 2).

Enqueueing of a priority 2 job

Rear 2 (6-30 pages)

Rear 3 (> 30 pages)

statssim

copybank

updateaverag

Note that if a priorityqueue were implementedusing an array, theaddition of an item mayrequire significantdata movement.

Linked lists are the betterchoice in this instance.

What does this indicate?

Rear 2 (6-30 pages)

Rear 3 (> 30 pages)

foobar

boomzowie

snarlmuddleheaded

Priority 2 is empty

Rear 2 (6-30 pages)

Rear 3 (> 30 pages)

foobar

boomzowie

snarlmuddleheaded

zilchIn general, If rear(n-1) == rear(n)Then priority n is empty.

Queues. Chapter Objectives 1.Understanding and applying the Queue ADT. 2.Implementing a Queue using...

Documents

Queues, Deques, and Priority Queues Chapter 14. 2 Chapter Contents Specifications for the ADT Queue Using a Queue to Simulate a Waiting Line The Classes

1 Queues (Walls & Mirrors - Chapter 7). 2 Overview The ADT Queue Linked-List Implementation of a Queue Array Implementation of a Queue

Priority Queues Two kinds of priority queues: Min priority queue. Max priority queue

CMSC 341 Deques, Stacks and Queues. 2/20/20062 The Double-Ended Queue ADT A Deque (rhymes with “check”) is a “Double Ended QUEue”. A Deque is a restricted

Chapter 3: Lists, Stacks and Queues Concept of Abstract Data Type (ADTS) How to efficiently perform operations on list Stack ADT and its applications Queue

Queues COL 106 - Indian Institute of Technology Delhimausam/courses/col106/autumn2017/lectures/04... · 17 The Double-Ended Queue ADT ( 5.3)• The Double-Ended Queue, or Deque, ADT

1 Queues Chapter 4. 2 Objectives You will be able to Describe a queue as an ADT. Build a dynamic array based implementation of a queue ADT

Agenda CPU Threads Flip Queue CPU Queues GPU Hardware Queue

ADT Lists, Stacks, and Queues · Lists, Stacks, and Queues Instructor: Ahmed Eldawy 1. Objectives Understand the importance of ADT Learn how to implement ADT in C++ Recognize the

CSE 326 Heaps and the Priority Queue ADT

Stacks, Queues, and Dequeshughm/ds/slides/20-stacks-queues-deques.pdf · Stacks, Queues, and Deques ... set the “deleted” array element to null ... A queue ADT Java does not provide

1 Queues What is a Queue? Queue Implementations: –Queue As Array –Queue As Circular Array –Queue As Linked List Some Applications of Queues Priority Queues

Queues & Priority Queues Radix Sort Heap Sort. Outline n Queues queue operationsqueue operations algorithms with queuesalgorithms with queues radix sortradix

Queues - Nathaniel G. Martinds.nathanielgmartin.com/wk09/W9L1-Queues.pdfOverview of Queue Applications of Queues Insertion and deletion in a Linear queue Implementation of Circular

CSCI 104 List ADT & Array-based Implementations Queues and ...ee.usc.edu/~redekopp/cs104/slides/L06_ArrayList_QueueStack.pdf · List ADT & Array-based Implementations Queues and Stacks

Chapter 6: Priority Queues (Heaps) Priority Queue ADT Heap Implementation CS 340 Page 100 Heap Applications Leftist Heaps

CS 1031 Queues Definition of a Queue Examples of Queues Design of a Queue Class Different Implementations of the Queue Class

Queue ADT Operations

Adapted from Data Structures with C++ using STL: Ford, Topp CS 362: Queues Dr. Nazli Mollah Overview of Lecture Introduction The Queue ADT The Radix

Advanced Object-oriented Programming Lecture 7akridel/COMP213-Fall2016...Advanced Object-oriented Programming Lecture 7 The Queue ADT. Stacks vs. Queues • The queue is the logical