Scribd
Upload
42 views

CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea

This document discusses queues and their implementation using arrays and linked lists. Queues follow the first-in, first-out (FIFO) principle where the first element inserted is the first to be removed. Array implementations require tracking both the front and rear indices while linked list implementations involve adding nodes to the rear and removing from the front. The time complexity of basic queue operations using both implementations is O(1) for enqueue, dequeue, size, isEmpty and isFull.

Uploaded by

Vicky Butt
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
42 views

CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea

This document discusses queues and their implementation using arrays and linked lists. Queues follow the first-in, first-out (FIFO) principle where the first element inserted is the first to be removed. Array implementations require tracking both the front and rear indices while linked list implementations involve adding nodes to the rear and removing from the front. The time complexity of basic queue operations using both implementations is O(1) for enqueue, dequeue, size, isEmpty and isFull.

Uploaded by

Vicky Butt
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 18

CSCE 3110

Data Structures &


Algorithm Analysis
Rada Mihalcea
http://www.cs.unt.edu/~rada/CSCE3110

Queues
Reading: Chap. 3 Weiss
Queue
Stores a set of elements in a particular order
Stack principle: FIRST IN FIRST OUT
= FIFO
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


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)
First In First Out

D rear
C rear C D rear
B rear B B C
rear front A front
A A front A front B
front
Applications: Job Scheduling
front rear Q[0] Q[1] Q[2] Q[3] Comments
-1 -1 queue is empty
-1 0 J1 Job 1 is added
-1 1 J1 J2 Job 2 is added
-1 2 J1 J2 J3 Job 3 is added
0 2 J2 J3 Job 1 is deleted
1 2 J3 Job 2 is deleted
Queue ADT
objects: a finite ordered list with zero or more elements.
methods:
for all queue  Queue, item  element,
max_ queue_ size  positive integer
Queue createQ(max_queue_size) ::=
create an empty queue whose maximum size is
max_queue_size
Boolean isFullQ(queue, max_queue_size) ::=
if(number of elements in queue == max_queue_size)
return TRUE
else return FALSE
Queue Enqueue(queue, item) ::=
if (IsFullQ(queue)) queue_full
else insert item at rear of queue and return queue
Queue ADT (cont’d)

Boolean isEmptyQ(queue) ::=


if (queue ==CreateQ(max_queue_size))
return TRUE
else return FALSE
Element dequeue(queue) ::=
if (IsEmptyQ(queue)) return
else remove and return the item at front of queue.
Array-based Queue
Implementation
As with the array-based stack
implementation, the array is of fixed size
A queue of maximum N elements
Slightly more complicated
Need to maintain track of both front and rear

Implementation 1

Implementation 2
Implementation 1:
createQ, isEmptyQ, isFullQ
Queue createQ(max_queue_size) ::=
# define MAX_QUEUE_SIZE 100/* Maximum queue size */
typedef struct {
int key;
/* other fields */
} element;
element queue[MAX_QUEUE_SIZE];
int rear = -1;
int front = -1;
Boolean isEmpty(queue) ::= front == rear
Boolean isFullQ(queue) ::= rear == MAX_QUEUE_SIZE-1
Implementation 1:
enqueue

void enqueue(int *rear, element item)


{
/* add an item to the queue */
if (*rear == MAX_QUEUE_SIZE_1) {
queue_full( );
return;
}
queue [++*rear] = item;
}
Implementation 1:
dequeue

element dequeue(int *front, int rear)


{
/* remove element at the front of the queue */
if ( *front == rear)
return queue_empty( ); /* return an error key */
return queue [++ *front];
}
Implementation 2:
Wrapped Configuration
EMPTY QUEUE
[2] [3] [2] [3]
J2 J3

[1] [4] [1] J1 [4]

[0] [5] [0] [5]

front = 0 front = 0
rear = 0 rear = 3

Can be seen as a circular queue


Leave one empty space when queue is full
Why?
FULL QUEUE FULL QUEUE

[2] [3] [2] [3]


J2 J3 J8 J9

[1] J1 J4 [4][1] J7 [4]

J5 J6 J5

[0] [5] [0] [5]

front =0 front =4
rear = 5 rear =3
How to test when queue is empty?
How to test when queue is full?
Enqueue in a Circular Queue

void enqueue(int front, int *rear, element item)


{
/* add an item to the queue */
*rear = (*rear +1) % MAX_QUEUE_SIZE;
if (front == *rear) /* reset rear and print error */
return;
}
queue[*rear] = item;
}
Dequeue from Circular Queue
element dequeue(int* front, int rear)
{
element item;
/* remove front element from the queue and put it in item */
if (*front == rear)
return queue_empty( );
/* queue_empty returns an error key */
*front = (*front+1) % MAX_QUEUE_SIZE;
return queue[*front];
}
List-based Queue
Implementation: Enqueue
void enqueue(pnode front, pnode rear, element item)
{ /* add an element to the rear of the queue */
pnode temp =
(pnode) malloc(sizeof (queue));
if (IS_FULL(temp)) {
fprintf(stderr, “ The memory is full\n”);
exit(1);
}
temp->item = item;
temp->next= NULL;
if (front) { (rear) -> next= temp;}
else front = temp;
rear = temp; }
Dequeue
element dequeue(pnode front) {
/* delete an element from the queue */
pnode temp = front;
element item;
if (IS_EMPTY(front)) {
fprintf(stderr, “The queue is
empty\n”);
exit(1);
}
item = temp->item;
front = temp->next;
free(temp);
return item;
Algorithm Analysis

enqueue O(?)
dequeue O(?)
size O(?)
isEmpty O(?)
isFull O(?)

What if I want the first element to be always


at Q[0] ?

You might also like