# Basic Operations for Queue in Data Structure

Last Updated : 03 Jan, 2023

## 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)

Previous
Next