A double-ended queue is a linear data structure which enables the user to add and remove integers from either ends i.e. from front or rear.

The details of the class DeQueue are given below:

Class name: DeQueue
Data members/instance variables:
qrr[]: array to hold integer elements
lim: maximum capacity of the dequeue
front: to point the index of the front end
rear: to point the index of the rear end
Methods/Member functions:
DeQueue(int l): constructor to initialize lim = l, front = 0 and rear = 0
void addFront(int v): to add integers in the dequeue at the front end if possible, otherwise display the message “OVERFLOW FROM FRONT”
void addRear(int v): to add integers in the dequeue at the rear end if possible, otherwise display the message “OVERFLOW FROM REAR”
int popFront(): removes and returns the integers from the front end of the dequeue if any, else returns -999
int popRear(): removes and returns the integers from the rear end of the dequeue if any, else returns -999
void show(): displays the elements of the dequeue

(i) Specify the class DeQueue giving details of the functions void addFront(int) and int popFront(). Assume that the other functions have been defined.

import java.util.Scanner;
class DeQueue{
    int qrr[];
    int lim;
    int front;
    int rear;
    public DeQueue(int l){
        lim = l;
        qrr = new int[lim];
        front = 0;
        rear = 0;
    }
    public void addFront(int v){
        if(front == 0)
            System.out.println("OVERFLOW FROM FRONT");
        else
            qrr[--front] = v;
    }
    public void addRear(int v){
        if(rear == lim)
            System.out.println("OVERFLOW FROM REAR");
        else
            qrr[rear++] = v;
    }
    public int popFront(){
        if(front < rear){
            int d = qrr[front++];
            if(front == rear){
                front = 0;
                rear = 0;
            }
            return d;
        }
        return -999;
    }
    public int popRear(){
        if(front < rear){
            int d = qrr[--rear];
            if(front == rear){
                front = 0;
                rear = 0;
            }
            return d;
        }
        return -999;
    }
    public void show(){
        if(front > rear)
            System.out.println("DE-QUEUE EMPTY");
        else{
            for(int i = front; i < rear; i++)
                System.out.print(qrr[i] + " ");
            System.out.println();
        }
    }
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.print("Dequeue limit: ");
        int size = Integer.parseInt(in.nextLine());
        DeQueue dq = new DeQueue(size);
        while(true){
            System.out.println("1. Add from front");
            System.out.println("2. Add from rear");
            System.out.println("3. Pop from front");
            System.out.println("4. Pop from rear");
            System.out.println("5. Display elements");
            System.out.print("Enter your choice: ");
            int choice = Integer.parseInt(in.nextLine());
            switch(choice){
            case 1:
                System.out.print("Element to be added: ");
                int v = Integer.parseInt(in.nextLine());
                dq.addFront(v);
                break;
            case 2:
                System.out.print("Element to be added: ");
                v = Integer.parseInt(in.nextLine());
                dq.addRear(v);
                break;
            case 3:
                v = dq.popFront();
                if(v == -999)
                    System.out.println("Underflow from front");
                else
                    System.out.println(v + " popped");
                break;
            case 4:
                v = dq.popRear();
                if(v == -999)
                    System.out.println("Underflow from rear");
                else
                    System.out.println(v + " popped");
                break;
            case 5:
                dq.show();
                break;
            default:
                System.out.println("Bye!");
                return;
            }
        }
    }
}

(ii) Differentiate between a stack and a queue.

A stack is a linear data structure that follows LIFO (Last In First Out) principle. A queue is a linear data structure that follows FIFO (First In First Out) principle.