Basic Operations for Queue in Data Structure

Queue is a linear data structure that follows FIFO (First In First Out) Principle, so the first element inserted is the first to be popped out.

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.
• getFront()- Acquires the data element available at the front node of the queue without deleting it.
• getRear() – 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.

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.

Operation 3: getFront()

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

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

• If the queue is empty, return the most minimum value (e.g., -1).
• Otherwise, return the front value of the queue.

getFront

Operation 4: getRear()

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.

getRear

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.

isEmpty

Operation 6: size()

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

size()

Code Implementation of all the operations:

#include <iostream>
#include <queue>
using namespace std;

queue<int> q;

bool isEmpty()
{
    return q.empty();
}

void qEnqueue(int data)
{
    q.push(data);
}

void qDequeue()
{
    if (isEmpty()) {
        return;
    }
    q.pop();
}

int getFront()
{
    if (isEmpty()) return -1;
    return q.front();
}

int getRear()
{
    if (isEmpty()) return -1;
    return q.back();
}

int main()
{
    qEnqueue(1);
    qEnqueue(8);
    qEnqueue(3);
    qEnqueue(6);
    qEnqueue(2);

    if (!isEmpty()) {
        cout << "Queue after enqueue operation: ";
        queue<int> tempQueue = q; 
        while (!tempQueue.empty()) {
            cout << tempQueue.front() << " ";
            tempQueue.pop();
        }
        cout << endl;
    }

    cout << "Front: " << getFront() << endl;
    cout << "Rear: " << getRear() << endl;

    cout << "Queue size: " << q.size() << endl;

    qDequeue();

    cout << "Is queue empty? " << (isEmpty() ? "Yes" : "No") << endl;

    return 0;
}

import java.util.LinkedList;
import java.util.Queue;

public class GfG {
    static Queue<Integer> q = new LinkedList<>();

    static boolean isEmpty() {
        return q.isEmpty();
    }

    static void qEnqueue(int data) {
        q.add(data);
    }

    static void qDequeue() {
        if (isEmpty()) {
            return;
        }
        q.poll();
    }

    static int getFront() {
        if (isEmpty()) return -1;
        return q.peek();
    }

    static int getRear() {
        if (isEmpty()) return -1;
        return ((LinkedList<Integer>) q).getLast();
    }

    public static void main(String[] args) {
        qEnqueue(1);
        qEnqueue(8);
        qEnqueue(3);
        qEnqueue(6);
        qEnqueue(2);

        if (!isEmpty()) {
            System.out.print("Queue after enqueue operation: ");
            for (int num : q) {
                System.out.print(num + " ");
            }
            System.out.println();
        }

        System.out.println("Front: " + getFront());
        System.out.println("Rear: " + getRear());

        System.out.println("Queue size: " + q.size());

        qDequeue();

        System.out.println("Is queue empty? " + (isEmpty() ? "Yes" : "No"));
    }
}

# Importing necessary modules
from collections import deque

q = deque()

def isEmpty():
    return len(q) == 0

def qEnqueue(data):
    q.append(data)

def qDequeue():
    if isEmpty():
        return
    q.popleft()

def getFront():
    if isEmpty():
        return -1
    return q[0]

def getRear():
    if isEmpty():
        return -1
    return q[-1]

if __name__ == '__main__':
    qEnqueue(1)
    qEnqueue(8)
    qEnqueue(3)
    qEnqueue(6)
    qEnqueue(2)

    if not isEmpty():
        print("Queue after enqueue operation: ", list(q))

    print("Front: ", getFront())
    print("Rear: ", getRear())

    print("Queue size: ", len(q))

    qDequeue()

    print("Is queue empty? ", "Yes" if isEmpty() else "No")

// Importing necessary namespaces
using System;
using System.Collections.Generic;

class GfG {
    static Queue<int> q = new Queue<int>();

    static bool IsEmpty() {
        return q.Count == 0;
    }

    static void QEnqueue(int data) {
        q.Enqueue(data);
    }

    static void QDequeue() {
        if (IsEmpty()) {
            return;
        }
        q.Dequeue();
    }

    static int GetFront() {
        if (IsEmpty()) return -1;
        return q.Peek();
    }

    static int GetRear() {
        if (IsEmpty()) return -1;
        return q.ToArray()[q.Count - 1];
    }

    static void Main() {
        QEnqueue(1);
        QEnqueue(8);
        QEnqueue(3);
        QEnqueue(6);
        QEnqueue(2);

        if (!IsEmpty()) {
            Console.WriteLine("Queue after enqueue operation: " + string.Join(" ", q));
        }

        Console.WriteLine("Front: " + GetFront());
        Console.WriteLine("Rear: " + GetRear());

        Console.WriteLine("Queue size: " + q.Count);

        QDequeue();

        Console.WriteLine("Is queue empty? " + (IsEmpty() ? "Yes" : "No"));
    }
}

// Using a class to implement a queue
class Queue {
    constructor() {
        this.items = [];
    }

    isEmpty() {
        return this.items.length === 0;
    }

    enqueue(data) {
        this.items.push(data);
    }

    dequeue() {
        if (this.isEmpty()) {
            return;
        }
        this.items.shift();
    }

    getFront() {
        if (this.isEmpty()) return -1;
        return this.items[0];
    }

    getRear() {
        if (this.isEmpty()) return -1;
        return this.items[this.items.length - 1];
    }

    size() {
        return this.items.length;
    }
}

const q = new Queue();

q.enqueue(1);
q.enqueue(8);
q.enqueue(3);
q.enqueue(6);
q.enqueue(2);

if (!q.isEmpty()) {
    console.log('Queue after enqueue operation: ', q.items);
}

console.log('Front: ', q.getFront());
console.log('Rear: ', q.getRear());
console.log('Queue size: ', q.size());

q.dequeue();

console.log('Is queue empty? ', q.isEmpty() ? 'Yes' : 'No');

Queue after enqueue operation: 1 8 3 6 2 
Front: 1
Rear: 2
Queue size: 5
Is queue empty? No