Q.

1-

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

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

Algorithm-

1. Start the program.

2. Initialize an array of fixed size for the deque (e.g., int qrr[] = new int[lim]).

3. Declare three variables: front, rear and lim.

4. Set front = 0, rear = 0 and lim=l to represent an empty deque.

5. Check queue is full or not:

 ○ If (front == 0 && rear == size-1) or (front == rear + 1), then Dqueue is
full.
6. If front == -1, then deque is empty.
7. Create addFront(int v) function.

8. In addFront(int v), check if deque is full.

9. If full, print "Overflow"; else proceed.

10. If empty (front == -1), set front = rear = 0.

11. Else if front == 0, set front = size - 1.

12. Else, decrement front--.

13. Insert element: qrr[front] = x.

14. Create addRear(int v) function.

15. Similar to addFront(int v), check for overflow, update rear pointer, and insert at
qrr[rear].

16. Create popFront() function:

● If deque is empty, return -999.

● If front == rear, set both to -1.
● Else if front == size - 1, set front = 0.
● Else, increment front.
17. Create int popRear() function:
● If empty, return -999.
● If front == rear, set both to -1.
● Else if rear == 0, set rear = size - 1.
● Else, decrement rear.
18. End of program; perform various operations as needed using addFront, addRear,
popFront, popRear.

Sol-
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;
}
}
}
}

Q.2-
Define a class CirQueue with the following details:

Class name: CirQueue

Data members/instance variables:

cq[]: array to store the integers

cap: stores the maximum capacity of the array
front: to point the index of the front end
rear: to point the index of the rear end

Member functions:

CirQueue(int max): constructor to initialize the data member cap = max, front = 0 and rear
=0
void push(int n): to add integer in the queue from the rear end if possible, otherwise
display the message “QUEUE IS FULL”
int pop(): removes and returns the integer from the front end of the queue if any, else
returns -9999
void show(): displays the queue elements
(a) Specify the class CirQueue giving details of the functions void push(int) and int
pop(). Assume that the other functions have been defined.

Algorithm-
1. Start the program.

2. Initialize a fixed-size array (e.g., int cq[] = new int[cap]).

3. Declare three variable: front, rear and cap.

 4. Set both front = 0, rear = 0 and cap=max to indicate an empty queue.

5. Check queue is full, if (front == 0 && rear == size - 1) or (rear + 1) % cap ==

front than print Queue is full

6. Check queue is empty, if front == -1 than return -9999.

7. Create an void push(int n) function to insert an element.

8. In void push(int n), first check . If full, print "Queue is full".

9. If queue is empty (front == -1), set front = 0.

10. Update rear = (rear + 1) % cap.

11. Insert the element: cq[rear] = n.

12. Create a int pop() function to delete an element.

13. In int pop(), check isEmpty(). If true, return -9999.

14. Store the front element (optional): temp = cq[front].

15. If front == rear, it means only one element. Set front = rear = -1.

16. Else, update front = (front + 1) % cap.

17. Return the dequeued element or simply confirm deletion.

18.End of program; use push, pop, and show to manage circular queue.

Sol-
import java.util.Scanner;
class CirQueue{
int cq[];
int cap;
int front;
int rear;
public CirQueue(int max){
cap = max;
cq = new int[cap];
front = 0;
rear = 0;
}
public void push(int v){
if(cap == 0)
System.out.println("QUEUE IS FULL");
else{
cq[rear] = v;
rear = (rear + 1) % cq.length;
cap--;
}
}
public int pop(){
if(cap == cq.length)
return -9999;
else{
int v = cq[front];
front = (front + 1) % cq.length;
cap++;
if(front == rear)
 front = rear = 0;
return v;
}
}
public void show(){
if(cap == cq.length)
System.out.println("QUEUE IS EMPTY");
else{
int i = front;
int count = cq.length;
while(count > cap){
System.out.print(cq[i] + " ");
i = (i + 1) % cq.length;
count--;
}
System.out.println();
}
}
public static void main(String args[]){
Scanner in = new Scanner(System.in);
System.out.print("Circular queue size: ");
int size = Integer.parseInt(in.nextLine());
CirQueue obj = new CirQueue(size);
while(true){
System.out.println("1. PUSH");
System.out.println("2. POP");
System.out.println("3. DISPLAY");
System.out.print("Enter your choice: ");
int choice = Integer.parseInt(in.nextLine());
switch(choice){
case 1:
System.out.print("Element to be pushed: ");
int d = Integer.parseInt(in.nextLine());
obj.push(d);
break;
case 2:
d = obj.pop();
if(d == -9999)
System.out.println("QUEUE IS EMPTY");
else
System.out.println(d + " POPPED");
break;
case 3:
obj.show();
break;
default:
System.out.println("Bye!");
return;
 }
}
}
}