# Circular Queue

Posted: 14 Feb, 2021

Difficulty: Easy

#### You will be given ‘Q’ queries. You need to implement a circular queue according to those queries. Each query will belong to one of these two types:

```
1 ‘X’: Enqueue element ‘X’ into the end of the nth queue. Returns true if the element is enqueued, otherwise false.
2: Dequeue the element at the front of the nth queue. Returns -1 if the queue is empty, otherwise, returns the dequeued element.
```

##### Note:

```
Enqueue means adding an element to the end of the queue, while Dequeue means removing the element from the front of the queue.
```

##### Input Format:

```
The first line of input contains two space-separated integers ‘N’ and ‘Q’ denoting the size of queue and number of queries, respectively.
The next ‘Q’ lines specify the type of operation/query to be performed on the data structure.
Each query contains an integer ‘P’ denoting the type of query.
For query of type 1, the integer ‘P’ is equal to 1 and it is followed by one integer ‘X’ denoting the element on which operation is to be performed.
For query of type 2, the integer ‘P’ is equal to 2 which dequeues the element.
```

##### Output Format:

```
For each query, return the output returned after performing the corresponding operation on the data structure.
Print the output of each test case in a separate line.
```

##### Note:

```
You don’t need to print anything. It has already been taken care of. You just have to complete the given functions.
```

##### Constraints:

```
1 <= N <= 1000
1 <= Q <= 10^5
1 <= P <= 2
1 <= X <= 10^5
Time limit: 1 sec
```

Approach 1

In this approach, we will be implementing a circular queue using arrays. A circular queue has two key methods or purpose:

- enqueue():
- Check whether the queue is full.
- A queue is full when the front is next to the rear. For example, with a queue of size 6, if front is 0 and rear is 5, or if front is 2 and rear is 1, it means that the queue is full.
- If it is full, then return false.
- If the queue is not full, then check if rear is the last index.
- If it is, set rear to 0;
- If it is not, increment rear and add the value at that index.

- Check whether the queue is full.
- dequeue():
- Check whether the queue is empty (i.e., if front/rear has a value of -1).
- If it is empty, the return -1.
- If the queue is not empty, then check if the queue has only one value (i.e., front == rear).
- If it does have only one value, set both rear and front to -1.
- If it does not, check if front is the last index of the queue and, if so, set front to 0, otherwise, increment front.

- Check whether the queue is empty (i.e., if front/rear has a value of -1).

SIMILAR PROBLEMS

# Two Sum II - Input Array Is Sorted

Posted: 4 Mar, 2022

Difficulty: Moderate

# Ninja And Matrix

Posted: 12 Apr, 2022

Difficulty: Easy

# Ninja In Interview

Posted: 13 Apr, 2022

Difficulty: Easy

# Missing Number

Posted: 17 Apr, 2022

Difficulty: Easy

# Min Heap

Posted: 5 May, 2022

Difficulty: Moderate