Outline

• Queues
• Operations on Queues
Data Structures – Week #4 • Array Implementation of Queues
• Linked List Implementation of Queues
Queues • Queue Applications

November 11, 2005 Borahan Tümer, Ph.D. 2

Queues (Kuyruklar) Operations on Queues

• A queue is a list of data with the restriction that • Two basic operations related to queues:
1. data can be inserted from the “rear” or “tail,” and – Enqueue (Put data to the rear of the queue)
2. Data can be retrieved from the “front” or “head”
– Dequeue (Retrieve data from the front of the
of the list.
queue)
• By “rear” we mean a pointer pointing to the
element that is last added to the list whereas
the front to the first element.
• A queue is a first-in-first-out (FIFO) structure.

November 11, 2005 Borahan Tümer, Ph.D. 3 November 11, 2005 Borahan Tümer, Ph.D. 4

Array Implementation of Queues Array Implementation of Queues

• Queues can be implemented using arrays. • Initialization:
– front=0; rear=-1;
• During the execution, queue can grow or • Condition for an empty queue:
shrink within this array. The array has two – In general: rear+1 = front
“open” ends.
– In particular: rear = -1;
• Condition for a full queue
• One end of the two open-ended array is the
– In general: rear-(n-1) = front;
rear where the insertions are made. The other
is the front where elements are removed. – In particular: rear t n-1;
November 11, 2005 Borahan Tümer, Ph.D. 5 November 11, 2005 Borahan Tümer, Ph.D. 6
 Sample C Implementation…
Sample C Implementation
isEmpty() and isFull()
#define queueSize …; //Initialize Queue (i.e., set value of front and rear to 0)
struct dataType { queue.rear=-1;
… int isEmpty(queueType q)
} {
typedef struct dataType dataType;
return (q.rear < q.front);
struct queueType {
}
int front;
int rear; int isFull(queueType q, int n)
dataType content[queueSize]; {
} return (q.rear >= n-1);
typedef struct queueType queueType; }
queueType queue;
November 11, 2005 Borahan Tümer, Ph.D. 7 November 11, 2005 Borahan Tümer, Ph.D. 8

Enqueue() Operation Enqueue Operation Animated

int enqueue(queueType *qp,int n,dataType item)
Empty Queue
{ a enqueued
b enqueued
if isFull(*qp) return 0; //unsuccessful insertion c enqueued
d enqueued
(*qp).content[++(*qp).rear]=item; …
k enqueued
return 1; //successful insertion l enqueued
}

An O(1) operation

November 11, 2005 Borahan Tümer, Ph.D. 9 November 11, 2005 Borahan Tümer, Ph.D. 10

Dequeue Operation O(n) Dequeue Operation Animated

int dequeue(queueType *qp,int n,dataType item)
{ a dequeued
b dequeued
if isEmpty(*qp) return 0; //unsuccessful removal c dequeued
d dequeued
item = (*qp).content[0]; // always: front = 0 …
for (i=1; i <= (*qp).rear; i++) k dequeued
l dequeued
(*qp).content[i-1]= (*qp).content[i]; Empty Queue
(*qp).rear--;
return 1; //successful removal
}
An O(n) operation
November 11, 2005 Borahan Tümer, Ph.D. 11 November 11, 2005 Borahan Tümer, Ph.D. 12
 Improved Dequeue Operation O(1) Dequeue Operation Animated
int dequeue(queueType *qp,int n,dataType item)
{ a dequeued
b dequeued
if isEmpty(*qp) return 0; //unsuccessful removal c dequeued
d dequeued
item = (*qp).content[(*qp).front++]; …
k dequeued
return 1; //successful insertion l dequeued
Empty Queue
}
An O(1) operation

November 11, 2005 Borahan Tümer, Ph.D. 13 November 11, 2005 Borahan Tümer, Ph.D. 14

Problem of O(1) Dequeue Circular Queues

• As front proceeds towards the larger indexed
elements in the queue, we get supposedly
available but inaccessible array cells in the
queue (i.e., all elements with indices less than
that pointed to by front).
• Whenever rear points to (n-1)st element, a shift
operation still needs to be carried out.
• Solution: attaching the end of the queue to the
start!!! Such queues we call circular queues.
November 11, 2005 Borahan Tümer, Ph.D. 15 November 11, 2005 Borahan Tümer, Ph.D. 16

Linked List Implementation of Queues Linked List Implementation of Queues

//Declaration of a queue node QueueNodePtr NodePtr, rear, front;
…
…
Struct QueueNode {
NodePtr = malloc(sizeof(QueueNode));
int data; rear = NodePtr;
struct QueueNode *next; NodePtr->data=2; // or rear->data=2
} NodePtr->next=NULL; // or rear->next=NULL;
typedef struct QueueNode QueueNode; Enqueue(&rear,&NodePtr);
typedef QueueNode * QueueNodePtr; …
Dequeue( );
…
…
November 11, 2005 Borahan Tümer, Ph.D. 17 November 11, 2005 Borahan Tümer, Ph.D. 18
 Enqueue and Dequeue Functions Linked List Implementation of Queues
Void Enqueue (QueueNodePtr *RearPtr, QueueNodePtr *NewNodePtr) {
*NewNodePtr = malloc(sizeof(QueueNode)); Void Push (StackNodePtr
NodePtr *TopPtr,
= malloc(sizeof(StackNode));
(*NewNodePtr)->data=5; StackNodePtr *NewNodePtr) {
top =*NewNodePtr
NodePtr; = malloc(sizeof(StackNode));
(*NewNodePtr)->next = *RearPtr; NodePtr->data=2; // or top->data=2
(*NewNodePtr)->data=5;
*RearPtr = *NewNodePtr; NodePtr->next=NULL;// or top->next=NULL;
(*NewNodePtr)->next =NULL;
} Push(&top,&NodePtr);
(*NewNodePtr)->next = *TopPtr;
*TopPtr = *NewNodePtr;
}
Void Dequeue(QueueNodePtr *FrontPtr) {
QueueNodePtr TempPtr;
TempPtr= *FrontPtr;
*FrontPtr = *FrontPtr->next;
free(TempPtr); // or you may return TempPtr!!!
}

November 11, 2005 Borahan Tümer, Ph.D. 19 November 11, 2005 Borahan Tümer, Ph.D. 20