Scribd
Upload
44 views33 pages

Queue

A queue is a first-in first-out (FIFO) data structure. It can be implemented using either a linear array or circular array. A queue uses two pointers - a front pointer pointing to the front element and a rear pointer pointing to the rear element. Elements are inserted at the rear and deleted from the front. Operations on a queue include enqueue to insert, dequeue to remove front element, isEmpty to check if empty, isFull to check if full. A queue can also be implemented using linked lists by adding nodes to the rear and deleting from the front.

Uploaded by

sanjib
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
44 views33 pages

Queue

A queue is a first-in first-out (FIFO) data structure. It can be implemented using either a linear array or circular array. A queue uses two pointers - a front pointer pointing to the front element and a rear pointer pointing to the rear element. Elements are inserted at the rear and deleted from the front. Operations on a queue include enqueue to insert, dequeue to remove front element, isEmpty to check if empty, isFull to check if full. A queue can also be implemented using linked lists by adding nodes to the rear and deleting from the front.

Uploaded by

sanjib
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 33

Queue

Queue
Data structure with First-In First-Out (FIFO) behavior
Queue
Data structure with First-In First-Out (FIFO) behavior

Out
In

B A
C B A
Typical Operations
on Queue REAR
Enqueue

isempty: determines if the queue is empty

isfull: determines if the queue is full


in case of a bounded size queue

front: returns the element at front of the queue

enqueue: inserts an element at the rear


Dequeue

dequeue: removes the element in front FRONT


Queue using array
What do we need?
1. An array to store the elements (of maximum size).
2. Two integer variables (array index) to indicate front and rear.

#define MAXSIZE 100


struct queue
{
int que[MAXSIZE];
int front,rear;
}; Rear Front
typedef struct queue QUEUE;

7 6 5 4 3 2 1 0
ENQUEUE
Increment rear
#define MAXSIZE 100 (array index)
struct queue
{
int que[MAXSIZE];
int front,rear;
};
typedef struct queue QUEUE;

Rear Rear Front

7 6 5 4 3 2 1 0
DEQUEUE
Increment front
(array index)
#define MAXSIZE 100
struct queue
{
int que[MAXSIZE];
int front,rear;
};
typedef struct queue QUEUE;

Rear FrontFront

7 6 5 4 3 2 1 0
Problem with Array implementation
 The size of the queue depends on the number and order
of enqueue and dequeue.
 It may be situation where memory is available but
enqueue is not possible.

ENQUEUE DEQUEUE
Effective queuing storage area of array gets reduced.
0 N

front
front rearrear
Use of circular array indexing
Possible Implementations
Linear Arrays:
Circular Arrays:
(static/dynamicaly allocated)
(static/dynamically allocated)

front rear

front
rear

Linked Lists: Use a linear


Can be implemented by a 1-d
linked list with insert_rear
array using modulus operations
and delete_front operations
Circular Queue
[3] [4]

[2] [5]

[1] [6]

[0] [7]

front=0
rear=0
Circular Queue
[3] [4] rear = 4
[3] [4]
C D
[2] [5]
[2] [5] B
After insertion
A
[1] [6] of A, B, C, D
[1] [6]

[0] [7] front=0 [0] [7]

front=0
rear=0
Circular Queue
[3] [4] rear = 4
[3] [4]
C D
[2] [5]
[2] [5] B
After insertion
A
[1] [6] of A, B, C, D
[1] [6]

[0] [7] front=0 [0] [7]

front=0
rear=0

[3] [4] rear = 4


front=2 C D
[2] [5]

After deletion of
[1] [6] of A, B

[0] [7]
front: index of queue-head (always empty – why?)
rear: index of last element, unless rear = front

[3] [4] rear = 3 front=4


[3] [4]

[2] [5]
[2] [5]

[1] [6] [1] [6]

[0] [7] [0] [7]


front=0
rear=0 Queue Empty Queue Full

Queue Empty Condition: front == rear


Queue Full Condition: front == (rear + 1) % MAX_Q_SIZE
Creating and Initializing a Circular
Queue
Declaration

#define MAX_Q_SIZE 100 Create and Initialize


typedef struct {
int key; /* just an example, can have
any type of fields depending queue Q;
on what is to be stored */
Q.front = 0;
} element;
typedef struct { Q.rear = 0;
element list[MAX_Q_SIZE];
int front, rear;
} queue;
Operations

int isfull (queue *q)


{
if (q->front == ((q->rear + 1) %
MAX_Q_SIZE))
return 1;
return 0; int isempty (queue *q)
} {
if (q->front == q->rear)
return 1;
return 0;
}
Operations
element front( queue *q )
{
return q->list[(q->front + 1) % MAX_Q_SIZE];
}

void enqueue( queue *q, element e)


{
q->rear = (q->rear + 1)% void dequeue( queue *q )
MAX_Q_SIZE; {
q->list[q->rear] = e; q-> front =
} (q-> front + 1)%
MAX_Q_SIZE;
}
Queue using linked list
 Create a linked list to which items would be
added to one end and deleted from the other
end.
 Two pointers will be maintained:
 One pointing to the beginning of the list (point from
where elements will be deleted).
 Another pointing to the end of the list (point where new
elements will be inserted). Rear

Front DELETION INSERTION


QUEUE: Insertion into a Linked List

ENQUEUE

front rear
QUEUE: Deletion from a Linked List

DEQUEUE

front rear

Free this node


QUEUE:: First-In-First-Out (FIFO)
Assume:: queue contains integer elements

void enqueue (QUEUE *q, int element);


/* Insert an element in the queue */
int dequeue (QUEUE *q);
/* Remove an element from the queue */
queue *create();
/* Create a new queue */
int isempty (QUEUE *q);
/* Check if queue is empty */
int size (QUEUE *q);
/* Return the no. of elements in queue */
int peek (QUEUE *q);
/* dequeue without removing element*/
enqueue ADT

dequeue

create
QUEUE
isempty

size
QUEUE using Linked List

struct qnode{
int val;
struct qnode *next;
};

struct queue{
struct qnode *qfront, *qrear;
};

typedef struct queue QUEUE;


QUEUE:: First-In-First-Out (FIFO)

Assume:: queue contains integer elements

void enqueue (QUEUE *q,int element)


{
struct qnode *q1;
q1=(struct qnode *)malloc(sizeof(struct
qnode));
q1->val= element;
q1->next=q->qfront;
q->qfront=q1;
}
QUEUE:: First-In-First-Out (FIFO)
Assume:: queue contains integer elements
int size (queue *q)
{
queue *q1;
int count=0;
q1=q;
while(q1!=NULL) {
q1=q1->next;
count++;
}
return count;
}
QUEUE:: First-In-First-Out (FIFO)

Assume:: queue contains integer elements

int peek (queue *q)


{
queue *q1;
q1=q;
while(q1->next!=NULL)
q1=q1->next;
return (q1->val);
}

Implement this using


QUEUE data structure.
QUEUE:: First-In-First-Out (FIFO)
Assume:: queue contains integer elements
int dequeue (queue *q)
{
int val;
queue *q1,*prev;
q1=q;
while(q1->next!=NULL) {
prev=q1;
q1=q1->next;
}
val=q1->val;
prev->next=NULL;
free(q1);
return (val);
} Implement this using
QUEUE data
structure.
Applications of Queues

 Direct applications
 Waiting lists.
 Access to shared resources (e.g., printer).
 Multiprogramming.

 Indirect applications
 Auxiliary data structure for algorithms
 Component of other data structures
Example 6: Print first N Fibonacci Numbers
using a Queue

The queue initially contains 0 and 1

rear front

1 0
Example 7: Use a Stack to reverse a Queue

rear front top

30 -5 18 14 14 18 -5 30

rear front

14 18 -5 30
Example 8: Create a new Queue with given
elements appended at the end of the Queue in a
reverse order

* Hint- You can use a stack in order to achieve the outcome


rear front

30 -5 18 14

rear front

14 18 -5 30 30 -5 18 14
Example 9: Implement a Stack using a Queue
data structure

For a given stack create a same size array which you are
going to use as a Queue.
Push and pop operation of stack’s should be emulated with
the Enqueue and Dequeue operation.
You can use an intermediate Queue for the above
implementation.
Homework
• Implement a Priority Queue which maintains the
items in an order (ascending/ descending) and
has additional functions like remove_max and
remove_min

• Maintain a Doctor’s appointment list


Thank You!

You might also like