Data Structures and

Algorithms

Lecture 14

Queues

Reading: Chapt. 3 - Weiss

Slides Ref. Dr. Sohail Aslam (VU)

Queue

Stores a set of elements in a particular order

A stack is LIFO (Last-In First Out) structure.

In contrast, a queue is a FIFO (First-In First-Out ) structure.

A queue is a linear structure for which items can be only inserted at one end and removed at another end.

It means: the first element inserted is the first one to be removed

Example

The first one in line is the first one to be served

Queues

Queue is an ordered-list in which all the insertions

and deletions are made at two different ends to

maintain the FIFO order.

Queue is implemented by maintaining one pointer to

the front element in the Queue and another pointer

pointing to the rear of the Queue.

Insertions are made at the rear and deletions are

made from the front.

Queue Applications

Real life examples

Waiting in line

Waiting on hold for tech support

Applications related to Computer Science

Threads

Job scheduling (e.g. Round-Robin algorithm for CPU

allocation)

ABA

CBA

DCBA

DCBrear

front

rearfront

rear

front

rear

front

rear

front

First In First Out

front rear Q[0] Q[1] Q[2] Q[3] Comments

-1

-1

-1

-1

0

1

-1

0

1

2

2

2

J1

J1 J2

J1 J2 J3

J2 J3

J3

queue is empty

Job 1 is added

Job 2 is added

Job 3 is added

Job 1 is deleted

Job 2 is deleted

Applications: Job Scheduling

Queue Operations

Enqueue(X) – place X at the rear of the queue.

Dequeue() -- remove the front element and return it.

Front() -- return front element without removing it.

IsEmpty() -- return TRUE if queue is empty, FALSE

otherwise

Implementing Queue

Using linked List: Recall

Insert works in constant time for either end of a

linked list.

Remove works in constant time only.

Seems best that head of the linked list be the front of

the queue so that all removes will be from the front.

Inserts will be at the end of the list.

Implementing Queue

Using linked List:

front

2571 1 7 5 2

frontrear rear

Implementing Queue

Using linked List:

front

2571 1 7 5 2

frontrear rear

front

257 1 7 5 2

frontrear rear

dequeue()

Implementing Queue

Using linked List:

front

2571 1 7 5 2

frontrear rear

front

257 97 5 2

frontrear rear

enqueue(9)

9

Implementing Queue

int dequeue()

{

int x = front->get();

Node* p = front;

front = front->getNext();

delete p;

return x;

}

void enqueue(int x)

{

Node* newNode = new Node();

newNode->set(x);

newNode->setNext(NULL);

rear->setNext(newNode);

rear = newNode;

}

Implementing Queue

int front()

{

return front->get();

}

int isEmpty()

{

return ( front == NULL );

}

Queue using Array

If we use an array to hold queue elements, both

insertions and removal at the front (start) of the array

are expensive.

This is because we may have to shift up to “n”

elements.

For the stack, we needed only one end; for queue

we need both.

To get around this, we will not shift upon removal of

an element.

Queue using Array

front

2571

rear

65 7

0

0 1 32 4

front

1 7 5 2

3

rear

Queue using Array

front

2571

rear

65 7

0

0 1 32 4

front

1 7 5 2

4

rear

enqueue(6)

66

Queue using Array

front

2571

rear

65 7

0

0 1 32 4

front

1 7 5 2

5

rear

enqueue(8)

66

88

Queue using Array

front

257

rear

65 7

1

0 1 32 4

front

7 5 2

5

rear

dequeue()

66

88

Queue using Array

front

25

rear

65 7

2

0 1 32 4

front

5 2

5

rear

dequeue()

66

88

Queue using Array

front

25

rear

65 7

2

0 1 32 4

front

5 2

7

rear

enqueue(9)

enqueue(12)

66

88

99

1212

enqueue(21) ??

Queue using Array

We have inserts and removal running in constant

time but we created a new problem.

Cannot insert new elements even though there are

two places available at the start of the array.

Solution: allow the queue to “wrap around”.

Queue using Array

Basic idea is to picture the array as a circular array.

front

25

rear2

front

7

rear

6 8 9 12

6

5

7

0 1

3

2

4

5

268

9

12

Queue using Array

void enqueue(int x)

{

rear = (rear+1)%size;

array[rear] = x;

noElements = noElements+1;

}

front

25

rear2

front

0

rear

6 8 9 12

6

5

7

0 1

3

2

4

5

268

9

12

enqueue(21)

21

218

size

7

noElements

Queue using Array

int isFull()

{

return noElements == size;

}

int isEmpty()

{

return noElements == 0;

}

front

25

rear2

front

1

rear

6 8 9 12

6

5

7

0 1

3

2

4

5

268

9

12

enqueue(7)

21

218

size

8

noElements

7

7

Queue using Array

int dequeue()

{

int x = array[front];

front = (front+1)%size;

noElements = noElements-1;

return x;

}

front rear4

front

1

rear

6 8 9 12

6

5

7

0 1

3

2

4

689

12

dequeue()

21

218

size

6

noElements

7

7