Queue | Set 1 (Introduction and Array Implementation)

04 Jul, 2022
Similar to Stack, Queue is a linear data structure that follows a particular order in which the operations are performed for storing data. The order is First In First Out (FIFO).  One can imagine a queue as a line of people waiting to receive something in sequential order which starts from the beginning of the line. It is an ordered list in which insertions are done at one end which is known as the rear and deletions are done from the other end known as the front. A good example of a queue is any queue of consumers for a resource where the consumer that came first is served first. The difference between stacks and queues is in removing. In a stack we remove the item the most recently added; in a queue, we remove the item the least recently added.Basic Operations on Queue: 
void enqueue(int data): Inserts an element at the end of the queue i.e. at the rear end.
int dequeue(): This operation removes and returns an element that is at the front end of the queue.
Auxiliary Operations on Queue:
int front(): This operation returns the element at the front end without removing it.
int rear(): This operation returns the element at the rear end without removing it.
int isEmpty(): This operation indicates whether the queue is empty or not.
int size(): This operation returns the size of the queue i.e. the total number of elements it contains.  
Types of Queues: 
Simple Queue: Simple queue also known as a linear queue is the most basic version of a queue. Here, insertion of an element i.e. the Enqueue operation takes place at the rear end and removal of an element i.e. the Dequeue operation takes place at the front end.
Circular Queue:  In a circular queue, the element of the queue act as a circular ring. The working of a circular queue is similar to the linear queue except for the fact that the last element is connected to the first element. Its advantage is that the memory is utilized in a better way. This is because if there is an empty space i.e. if no element is present at a certain position in the queue, then an element can be easily added at that position.
Priority Queue: This queue is a special type of queue. Its specialty is that it arranges the elements in a queue based on some priority. The priority can be something where the element with the highest value has the priority so it creates a queue with decreasing order of values. The priority can also be such that the element with the lowest value gets the highest priority so in turn it creates a queue with increasing order of values.
Dequeue: Dequeue is also known as Double Ended Queue. As the name suggests double ended, it means that an element can be inserted or removed from both the ends of the queue unlike the other queues in which it can be done only from one end. Because of this property it may not obey the First In First Out property. 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Applications of Queue: Queue is used when things don’t have to be processed immediately, but have to be processed in First In First Out order like Breadth First Search. This property of Queue makes it also useful in following kind of scenarios.1) When a resource is shared among multiple consumers. Examples include CPU scheduling, Disk Scheduling. 2) When data is transferred asynchronously (data not necessarily received at same rate as sent) between two processes. Examples include IO Buffers, pipes, file IO, etc. 
3) Queue can be used as an essential component in various other data structures.See this for more detailed applications of Queue and Stack.Array implementation Of Queue For implementing queue, we need to keep track of two indices, front and rear. We enqueue an item at the rear and dequeue an item from the front. If we simply increment front and rear indices, then there may be problems, the front may reach the end of the array. The solution to this problem is to increase front and rear in circular manner.
Steps for ENQUEUE
Check the queue is full or notIf full, print overflow and exitIf queue is not full, increment tail and add the element
Check the queue is full or not
If full, print overflow and exit
If queue is not full, increment tail and add the element
Steps for DEQUEUE
Check queue is empty or notif empty, print underflow and exitif not empty, print element at the head and increment head
Check queue is empty or not
if empty, print underflow and exit
if not empty, print element at the head and increment head
C++
C
Java
Python3
C#
// CPP program for array// implementation of queue#include <bits/stdc++.h>using namespace std;  // A structure to represent a queueclass Queue {public:    int front, rear, size;    unsigned capacity;    int* array;};  // function to create a queue// of given capacity.// It initializes size of queue as 0Queue* createQueue(unsigned capacity){    Queue* queue = new Queue();    queue->capacity = capacity;    queue->front = queue->size = 0;      // This is important, see the enqueue    queue->rear = capacity - 1;    queue->array = new int[queue->capacity];    return queue;}  // Queue is full when size// becomes equal to the capacityint isFull(Queue* queue){    return (queue->size == queue->capacity);}  // Queue is empty when size is 0int isEmpty(Queue* queue){    return (queue->size == 0);}  // Function to add an item to the queue.// It changes rear and sizevoid enqueue(Queue* queue, int item){    if (isFull(queue))        return;    queue->rear = (queue->rear + 1)                  % queue->capacity;    queue->array[queue->rear] = item;    queue->size = queue->size + 1;    cout << item << " enqueued to queue\n";}  // Function to remove an item from queue.// It changes front and sizeint dequeue(Queue* queue){    if (isEmpty(queue))        return INT_MIN;    int item = queue->array[queue->front];    queue->front = (queue->front + 1)                   % queue->capacity;    queue->size = queue->size - 1;    return item;}  // Function to get front of queueint front(Queue* queue){    if (isEmpty(queue))        return INT_MIN;    return queue->array[queue->front];}  // Function to get rear of queueint rear(Queue* queue){    if (isEmpty(queue))        return INT_MIN;    return queue->array[queue->rear];}  // Driver codeint main(){    Queue* queue = createQueue(1000);      enqueue(queue, 10);    enqueue(queue, 20);    enqueue(queue, 30);    enqueue(queue, 40);      cout << dequeue(queue)         << " dequeued from queue\n";      cout << "Front item is "         << front(queue) << endl;    cout << "Rear item is "         << rear(queue) << endl;      return 0;}  // This code is contributed by rathbhupendra
// C program for array implementation of queue#include <limits.h>#include <stdio.h>#include <stdlib.h>  // A structure to represent a queuestruct Queue {    int front, rear, size;    unsigned capacity;    int* array;};  // function to create a queue// of given capacity.// It initializes size of queue as 0struct Queue* createQueue(unsigned capacity){    struct Queue* queue = (struct Queue*)malloc(        sizeof(struct Queue));    queue->capacity = capacity;    queue->front = queue->size = 0;      // This is important, see the enqueue    queue->rear = capacity - 1;    queue->array = (int*)malloc(        queue->capacity * sizeof(int));    return queue;}  // Queue is full when size becomes// equal to the capacityint isFull(struct Queue* queue){    return (queue->size == queue->capacity);}  // Queue is empty when size is 0int isEmpty(struct Queue* queue){    return (queue->size == 0);}  // Function to add an item to the queue.// It changes rear and sizevoid enqueue(struct Queue* queue, int item){    if (isFull(queue))        return;    queue->rear = (queue->rear + 1)                  % queue->capacity;    queue->array[queue->rear] = item;    queue->size = queue->size + 1;    printf("%d enqueued to queue\n", item);}  // Function to remove an item from queue.// It changes front and sizeint dequeue(struct Queue* queue){    if (isEmpty(queue))        return INT_MIN;    int item = queue->array[queue->front];    queue->front = (queue->front + 1)                   % queue->capacity;    queue->size = queue->size - 1;    return item;}  // Function to get front of queueint front(struct Queue* queue){    if (isEmpty(queue))        return INT_MIN;    return queue->array[queue->front];}  // Function to get rear of queueint rear(struct Queue* queue){    if (isEmpty(queue))        return INT_MIN;    return queue->array[queue->rear];}  // Driver program to test above functions./int main(){    struct Queue* queue = createQueue(1000);      enqueue(queue, 10);    enqueue(queue, 20);    enqueue(queue, 30);    enqueue(queue, 40);      printf("%d dequeued from queue\n\n",           dequeue(queue));      printf("Front item is %d\n", front(queue));    printf("Rear item is %d\n", rear(queue));      return 0;}
// Java program for array// implementation of queue  // A class to represent a queueclass Queue {    int front, rear, size;    int capacity;    int array[];      public Queue(int capacity)    {        this.capacity = capacity;        front = this.size = 0;        rear = capacity - 1;        array = new int[this.capacity];    }      // Queue is full when size becomes    // equal to the capacity    boolean isFull(Queue queue)    {        return (queue.size == queue.capacity);    }      // Queue is empty when size is 0    boolean isEmpty(Queue queue)    {        return (queue.size == 0);    }      // Method to add an item to the queue.    // It changes rear and size    void enqueue(int item)    {        if (isFull(this))            return;        this.rear = (this.rear + 1)                    % this.capacity;        this.array[this.rear] = item;        this.size = this.size + 1;        System.out.println(item                           + " enqueued to queue");    }      // Method to remove an item from queue.    // It changes front and size    int dequeue()    {        if (isEmpty(this))            return Integer.MIN_VALUE;          int item = this.array[this.front];        this.front = (this.front + 1)                     % this.capacity;        this.size = this.size - 1;        return item;    }      // Method to get front of queue    int front()    {        if (isEmpty(this))            return Integer.MIN_VALUE;          return this.array[this.front];    }      // Method to get rear of queue    int rear()    {        if (isEmpty(this))            return Integer.MIN_VALUE;          return this.array[this.rear];    }}  // Driver classpublic class Test {    public static void main(String[] args)    {        Queue queue = new Queue(1000);          queue.enqueue(10);        queue.enqueue(20);        queue.enqueue(30);        queue.enqueue(40);          System.out.println(queue.dequeue()                           + " dequeued from queue\n");          System.out.println("Front item is "                           + queue.front());          System.out.println("Rear item is "                           + queue.rear());    }}  // This code is contributed by Gaurav Miglani
# Python3 program for array implementation of queue  # Class Queue to represent a queueclass Queue:      # __init__ function    def __init__(self, capacity):        self.front = self.size = 0        self.rear = capacity -1        self.Q = [None]*capacity        self.capacity = capacity          # Queue is full when size becomes    # equal to the capacity     def isFull(self):        return self.size == self.capacity          # Queue is empty when size is 0    def isEmpty(self):        return self.size == 0      # Function to add an item to the queue.     # It changes rear and size    def EnQueue(self, item):        if self.isFull():            print("Full")            return        self.rear = (self.rear + 1) % (self.capacity)        self.Q[self.rear] = item        self.size = self.size + 1        print("% s enqueued to queue"  % str(item))      # Function to remove an item from queue.     # It changes front and size    def DeQueue(self):        if self.isEmpty():            print("Empty")            return                  print("% s dequeued from queue" % str(self.Q[self.front]))        self.front = (self.front + 1) % (self.capacity)        self.size = self.size -1              # Function to get front of queue    def que_front(self):        if self.isEmpty():            print("Queue is empty")          print("Front item is", self.Q[self.front])              # Function to get rear of queue    def que_rear(self):        if self.isEmpty():            print("Queue is empty")        print("Rear item is",  self.Q[self.rear])    # Driver Codeif __name__ == '__main__':      queue = Queue(30)    queue.EnQueue(10)    queue.EnQueue(20)    queue.EnQueue(30)    queue.EnQueue(40)    queue.DeQueue()    queue.que_front()    queue.que_rear()
// C# program for array implementation of queueusing System;  namespace GeeksForGeeks {// A class to represent a linearqueueclass Queue {    private int[] ele;    private int front;    private int rear;    private int max;      public Queue(int size)    {        ele = new int[size];        front = 0;        rear = -1;        max = size;    }      // Function to add an item to the queue.    // It changes rear and size    public void enqueue(int item)    {        if (rear == max - 1) {            Console.WriteLine("Queue Overflow");            return;        }        else {            ele[++rear] = item;        }    }      // Function to remove an item from queue.    // It changes front and size    public int dequeue()    {        if (front == rear + 1) {            Console.WriteLine("Queue is Empty");            return -1;        }        else {            Console.WriteLine(ele[front] + " dequeued from queue");            int p = ele[front++];            Console.WriteLine();            Console.WriteLine("Front item is {0}", ele[front]);            Console.WriteLine("Rear item is {0} ", ele[rear]);            return p;        }    }      // Function to print queue.    public void printQueue()    {        if (front == rear + 1) {            Console.WriteLine("Queue is Empty");            return;        }        else {            for (int i = front; i <= rear; i++) {                Console.WriteLine(ele[i] + " enqueued to queue");            }        }    }}  // Driver codeclass Program {    static void Main()    {        Queue Q = new Queue(5);          Q.enqueue(10);        Q.enqueue(20);        Q.enqueue(30);        Q.enqueue(40);        Q.printQueue();        Q.dequeue();    }}}
Output: 
10 enqueued to queue
20 enqueued to queue
30 enqueued to queue
40 enqueued to queue
10 dequeued from queue
Front item is 20
Rear item is 40
Complexity Analysis:  
Time Complexity:
Operations              Complexity
Enque(insertion)           O(1)
Deque(deletion)            O(1)
Front(Get front)           O(1)
Rear(Get Rear)             O(1)              
Auxiliary Space: O(N). N is the size of array for storing elements.
Pros of Array Implementation:  
Easy to implement.
Easy to implement.
Cons of Array Implementation:  
Static Data Structure, fixed size.If the queue has a large number of enqueue and dequeue operations, at some point (in case of linear increment of front and rear indexes) we may not be able to insert elements in the queue even if the queue is empty (this problem is avoided by using circular queue).
Static Data Structure, fixed size.
If the queue has a large number of enqueue and dequeue operations, at some point (in case of linear increment of front and rear indexes) we may not be able to insert elements in the queue even if the queue is empty (this problem is avoided by using circular queue).
Linked list implementation is easier, it is discussed here: Queue | Set 2 (Linked List Implementation)Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
SoumikMondal
rathbhupendra
Archaic
bidibaaz123
govindtomar94
laroracoding
krishna_97
guptavivek0503
shreyasnaphad
Goldman Sachs
Arrays
Queue
Goldman Sachs
Arrays
Queue
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Arrays in Java
Write a program to reverse an array or string
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Largest Sum Contiguous Subarray
Breadth First Search or BFS for a Graph
Level Order Binary Tree Traversal
Queue in Python
Queue Interface In Java
Introduction to Data Structures