GeeksforGeeks App
Open App
Browser
Continue

# Basic Operations for Queue in Data Structure

## Basic Operations on Queue:

Some of the basic operations for Queue in Data Structure are:

• enqueue() – Insertion of elements to the queue.
• dequeue() – Removal of elements from the queue.
• peek() or front()- Acquires the data element available at the front node of the queue without deleting it.
• rear() – This operation returns the element at the rear end without removing it.
• isFull() – Validates if the queue is full.
• isEmpty() – Checks if the queue is empty.
• size(): This operation returns the size of the queue i.e. the total number of elements it contains.

Queue Data Structure

### Operation 1: enqueue()

Inserts an element at the end of the queue i.e. at the rear end.

The following steps should be taken to enqueue (insert) data into a queue:

• Check if the queue is full.
• If the queue is full, return overflow error and exit.
• If the queue is not full, increment the rear pointer to point to the next empty space.
• Add the data element to the queue location, where the rear is pointing.
• return success.

Enqueue representation

Below is the Implementation of the above approach:

## C++

 `void` `queueEnqueue(``int` `data)``{``    ``// Check queue is full or not``    ``if` `(capacity == rear) {``        ``printf``(``"\nQueue is full\n"``);``        ``return``;``    ``}` `    ``// Insert element at the rear``    ``else` `{``        ``queue[rear] = data;``        ``rear++;``    ``}``    ``return``;``}`

## Java

 `void` `queueEnqueue(``int` `data)``{``    ``// Check queue is full or not``    ``if` `(capacity == rear) {``        ``System.out.println(``"\nQueue is full\n"``);``        ``return``;``    ``}` `    ``// Insert element at the rear``    ``else` `{``        ``queue[rear] = data;``        ``rear++;``    ``}``    ``return``;``}` `// This code is contributed by aadityapburujwale`

## C

 `// Function to add an item to the queue.``// It changes rear and size``void` `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);``}` `// This code is contributed by Susobhan Akhuli`

## Python3

 `# 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))``# This code is contributed by Susobhan Akhuli`

## C#

 `// 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;``    ``}``}` `// This code is contributed by Susobhan Akhuli`

## Javascript

 ``

Complexity Analysis:
Time Complexity: O(1)
Space Complexity: O(N)

### Operation 2: dequeue()

This operation removes and returns an element that is at the front end of the queue.

The following steps are taken to perform the dequeue operation:

• Check if the queue is empty.
• If the queue is empty, return the underflow error and exit.
• If the queue is not empty, access the data where the front is pointing.
• Increment the front pointer to point to the next available data element.
• The Return success.

Dequeue operation

Below is the Implementation of above approach:

## C++

 `void` `queueDequeue()``{``    ``// If queue is empty``    ``if` `(front == rear) {``        ``printf``(``"\nQueue is empty\n"``);``        ``return``;``    ``}` `    ``// Shift all the elements from index 2``    ``// till rear to the left by one``    ``else` `{``        ``for` `(``int` `i = 0; i < rear - 1; i++) {``            ``queue[i] = queue[i + 1];``        ``}` `        ``// decrement rear``        ``rear--;``    ``}``    ``return``;``}`

## Java

 `void` `queueDequeue()``{``    ``// If queue is empty``    ``if` `(front == rear) {``        ``System.out.println(``"\nQueue is empty\n"``);``        ``return``;``    ``}` `    ``// Shift all the elements from index 2``    ``// till rear to the left by one``    ``else` `{``        ``for` `(``int` `i = ``0``; i < rear - ``1``; i++) {``            ``queue[i] = queue[i + ``1``];``        ``}` `        ``// decrement rear``        ``rear--;``    ``}``    ``return``;``}` `// This code is contributed by aadityapburujwale`

## C

 `// Function to remove an item from queue.``// It changes front and size``int` `dequeue(``struct` `Queue* queue)``{``    ``if` `(isEmpty(queue)) {``        ``printf``(``"\nQueue is empty\n"``);``        ``return``;``    ``}``    ``int` `item = queue->array[queue->front];``    ``queue->front = (queue->front + 1) % queue->capacity;``    ``queue->size = queue->size - 1;``    ``return` `item;``}` `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Function to remove an item from queue.``# It changes front and size`  `def` `DeQueue(``self``):``    ``if` `self``.isEmpty():``        ``print``(``"Queue is empty"``)``        ``return` `    ``print``(``"% s dequeued from queue"` `%` `str``(``self``.Q[``self``.front]))``    ``self``.front ``=` `(``self``.front ``+` `1``) ``%` `(``self``.capacity)``    ``self``.size ``=` `self``.size ``-` `1``# This code is contributed by Susobhan Akhuli`

## C#

 `// 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` `{``        ``int` `p = ele[front++];``        ``return` `p;``    ``}``}``// This code is contributed by Susobhan Akhuli`

## Javascript

 ``

Complexity Analysis:
Time Complexity: O(1)
Space Complexity: O(N)

### Operation 3: front()

This operation returns the element at the front end without removing it.

The following steps are taken to perform the front operation:

• If the queue is empty return the most minimum value.
• otherwise, return the front value.

Below is the Implementation of the above approach:

## C++

 `// Function to get front of queue``int` `front(Queue* queue)``{``    ``if` `(isempty(queue))``        ``return` `INT_MIN;``    ``return` `queue->arr[queue->front];``}`

## Java

 `// Function to get front of queue``int` `front(Queue queue)``{``    ``if` `(isempty(queue))``        ``return` `Integer.MIN_VALUE;``    ``return` `queue.arr[queue.front];``}` `// This code is contributed by aadityapburujwale`

## C

 `// Function to get front of queue``int` `front(``struct` `Queue* queue)``{``    ``if` `(isempty(queue))``        ``return` `INT_MIN;``    ``return` `queue->arr[queue->front];``}` `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Function to get front of queue``def` `que_front(``self``):``        ``if` `self``.isempty():``            ``return` `"Queue is empty"``        ``return` `self``.Q[``self``.front]` `# This code is contributed By Susobhan Akhuli`

## C#

 `// Function to get front of queue``public` `int` `front()``{``    ``if` `(isempty())``        ``return` `INT_MIN;``    ``return` `arr[front];``}` `// This code is contributed By Susobhan Akhuli`

## Javascript

 `

Complexity Analysis:
Time Complexity: O(1)
Space Complexity: O(N)

### Operation 4 : rear()

This operation returns the element at the rear end without removing it.

The following steps are taken to perform the rear operation:

• If the queue is empty return the most minimum value.
• otherwise, return the rear value.

Below is the Implementation of the above approach:

## C++

 `// Function to get rear of queue``int` `rear(Queue* queue)``{``    ``if` `(isEmpty(queue))``        ``return` `INT_MIN;``    ``return` `queue->arr[queue->rear];``}`

## Java

 `// Function to get rear of queue``int` `rear(Queue queue)``{``    ``if` `(isEmpty(queue))``        ``return` `Integer.MIN_VALUE;``    ``return` `queue.arr[queue.rear];``}` `// This code is contributed by aadityapburujwale`

## C

 `// Function to get front of queue``int` `front(``struct` `Queue* queue)``{``    ``if` `(isempty(queue))``        ``return` `INT_MIN;``    ``return` `queue->arr[queue->rear];``}` `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Function to get rear of queue``def` `que_rear(``self``):``        ``if` `self``.isEmpty():``            ``return` `"Queue is empty"``        ``return` `self``.Q[``self``.rear]` `# This code is contributed By Susobhan Akhuli`

## C#

 `// Function to get front of queue``public` `int` `front()``{``    ``if` `(isempty())``        ``return` `INT_MIN;``    ``return` `arr[rear];``}` `// This code is contributed By Susobhan Akhuli`

## Javascript

 `

Complexity Analysis:
Time Complexity: O(1)
Space Complexity: O(N)

### Operation 5: isEmpty():

This operation returns a boolean value that indicates whether the queue is empty or not.

The following steps are taken to perform the Empty operation:

• check if front value is equal to -1 or not, if yes then return true means queue is empty.
• Otherwise return false, means queue is not empty

Below is the implementation of the above approach:

## C++

 `// This function will check whether``// the queue is empty or not:``bool` `isEmpty()``{``    ``if` `(front == -1)``        ``return` `true``;``    ``else``        ``return` `false``;``}`

## Java

 `// This function will check whether``// the queue is empty or not:``boolean` `isEmpty()``{``    ``if` `(front == -``1``)``        ``return` `true``;``    ``else``        ``return` `false``;``}` `// This code is contributed by aadityapburujwale`

## C#

 `// This function will check whether``// the queue is empty or not:``bool` `isEmpty()``{``    ``if` `(front == -1)``        ``return` `true``;``    ``else``        ``return` `false``;``}` `// This code is contributed by lokeshmvs21.`

## C

 `// Queue is empty when size is 0``bool` `isEmpty(``struct` `Queue* queue)``{``    ``return` `(queue->size == 0);``}` `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Queue is empty when size is 0``def` `isEmpty(``self``):``    ``return` `self``.size ``=``=` `0``# This code is contributed by Susobhan Akhuli`

## Javascript

 ```isEmpty(){``    ``// return true if the queue is empty.``    ``return` `this``.items.length == 0;``}``// This code is contributed by Susobhan Akhuli```

Complexity Analysis:
Time Complexity: O(1)
Space Complexity: O(N)

### Operation 6 : isFull()

This operation returns a boolean value that indicates whether the queue is full or not.

The following steps are taken to perform the isFull() operation:

• Check if front value is equal to zero and rear is equal to the capacity of queue if yes then return true.
• otherwise return false

Below is the Implementation of the above approach:

## C++

 `// This function will check``// whether the queue is full or not.``bool` `isFull()``{``    ``if` `(front == 0 && rear == MAX_SIZE - 1) {``        ``return` `true``;``    ``}``    ``return` `false``;``}`

## Java

 `// This function will check``// whether the queue is full or not.``boolean` `isFull()``{``    ``if` `(front == ``0` `&& rear == MAX_SIZE - ``1``) {``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// This code is contributed by aadityapburujwale`

## C

 `// Queue is full when size becomes``// equal to the capacity``bool` `isFull(``struct` `Queue* queue)``{``    ``return` `(queue->size == queue->capacity);``}` `// This code is contributed by Susobhan Akhuli`

## C#

 `// Function to add an item to the queue.``// It changes rear and size``public` `bool` `isFull(``int` `item) { ``return` `(rear == max - 1); }``// This code is contributed by Susobhan Akhuli`

## Python3

 `# Queue is full when size becomes``# equal to the capacity`  `def` `isFull(``self``):``    ``return` `self``.size ``=``=` `self``.capacity` `# This code is contributed by Susobhan Akhuli`

## Javascript

 `function` `isFull() {``  ``if` `(front == 0 && rear == MAX_SIZE - 1) {``    ``return` `true``;``  ``}``  ``return` `false``;``}` `// This code is contributed by aadityamaharshi21.`

Complexity Analysis:
Time Complexity: O(1)
Space Complexity: O(N)

### Operation 7: size()

This operation returns the size of the queue i.e. the total number of elements it contains.

```queuename.size()
Parameters :
No parameters are passed
Returns :
Number of elements in the container```

## C++

 `// CPP program to illustrate``// Implementation of size() function``#include ``#include ``using` `namespace` `std;` `int` `main()``{``    ``int` `sum = 0;``    ``queue<``int``> myqueue;``    ``myqueue.push(1);``    ``myqueue.push(8);``    ``myqueue.push(3);``    ``myqueue.push(6);``    ``myqueue.push(2);` `    ``// Queue becomes 1, 8, 3, 6, 2` `    ``cout << myqueue.size();` `    ``return` `0;``}`

## Java

 `// Java program to illustrate implementation of size()``// function` `import` `java.util.*;` `public` `class` `Main {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `sum = ``0``;``        ``Queue myqueue = ``new` `LinkedList<>();``        ``myqueue.add(``1``);``        ``myqueue.add(``8``);``        ``myqueue.add(``3``);``        ``myqueue.add(``6``);``        ``myqueue.add(``2``);` `        ``// Queue becomes 1, 8, 3, 6, 2` `        ``System.out.println(myqueue.size());``    ``}``}` `// This code is contributed by lokesh.`

## Python

 `from` `collections ``import` `deque` `def` `main():``    ``sum` `=` `0``    ``myqueue ``=` `deque()``    ``myqueue.append(``1``)``    ``myqueue.append(``8``)``    ``myqueue.append(``3``)``    ``myqueue.append(``6``)``    ``myqueue.append(``2``)` `    ``# Queue becomes 1, 8, 3, 6, 2` `    ``print``(``len``(myqueue))` `main()` `# This code is contributed by aadityamaharshi21.`

## C#

 `using` `System;``using` `System.Collections.Generic;` `namespace` `ConsoleApp1 {``  ``class` `MainClass {``    ``public` `static` `void` `Main(``string``[] args)``    ``{``      ``int` `sum = 0;``      ``Queue<``int``> myqueue = ``new` `Queue<``int``>();``      ``myqueue.Enqueue(1);``      ``myqueue.Enqueue(8);``      ``myqueue.Enqueue(3);``      ``myqueue.Enqueue(6);``      ``myqueue.Enqueue(2);` `      ``// Queue becomes 1, 8, 3, 6, 2` `      ``Console.WriteLine(myqueue.Count);``    ``}``  ``}``}` `// This code is contributed by adityamaharshi21.`

## Javascript

 `// Javascript code``let sum = 0;``let myqueue=[];``myqueue.push(1);``myqueue.push(8);``myqueue.push(3);``myqueue.push(6);``myqueue.push(2);` `// Queue becomes 1, 8, 3, 6, 2` `console.log(myqueue.length);`

Complexity Analysis:
Time Complexity: O(1)
Space Complexity: O(N)

My Personal Notes arrow_drop_up