C Programs Tutorials | IT Developer
IT Developer

Java Programs - Solved 2023 Theory Paper ISC Computer Science

Share with a Friend
Previous
HOME
Next

Solved 2023 Thory Paper ISC Computer Science

Class 12 - ISC Computer Science Solved Theory Papers

DeQueue Data Structure Program - ISC 2023 Theory

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.

 

(ii) Differentiate between a stack and a queue.
Java 
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;
            }
        }
    }
}

Output

 

OUTPUT :

Dequeue limit: 5
1. Add from front
2. Add from rear
3. Pop from front
4. Pop from rear
5. Display elements
Enter your choice: 1
Element to be added: 10
OVERFLOW FROM FRONT
1. Add from front
2. Add from rear
3. Pop from front
4. Pop from rear
5. Display elements
Enter your choice: 2
Element to be added: 20
1. Add from front
2. Add from rear
3. Pop from front
4. Pop from rear
5. Display elements
Enter your choice: 1
Element to be added: 30
OVERFLOW FROM FRONT
1. Add from front
2. Add from rear
3. Pop from front
4. Pop from rear
5. Display elements
Enter your choice: 2
Element to be added: 40
1. Add from front
2. Add from rear
3. Pop from front
4. Pop from rear
5. Display elements
Enter your choice: 5
20 40 
1. Add from front
2. Add from rear
3. Pop from front
4. Pop from rear
5. Display elements
Enter your choice: 


(ii).  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.
Previous
Next