C Programs Tutorials | IT Developer
IT Developer

Java Programs - Solved 2020 Theory Paper ISC Computer Science

Share with a Friend
Previous
HOME
Next

Solved 2020 Theory Paper ISC Computer Science

Class 12 - ISC Computer Science Solved Theory Papers

Circular Queue Program - ISC 2020 Theory

A Circular Queue is a linear data structure which works on the principle of FIFO, enables the user to enter data from the rear end and remove data from the front end with the rear end connected to the front end to form a circular pattern.

Define a class CirQueue with the following details:

Class name: CirQueue
Data members/instance variables:
cq[]: array to store 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.

The main function and algorithm need not be written.

(b) How is a linear queue structure different from a circular queue structure?

Java 
  class CirQueue {
    private int[] cq;
    private int cap;
    private int front;
    private int rear;

    // Constructor
    public CirQueue(int max) {
        cap = max + 1; // one slot is left empty to differentiate full vs empty
        cq = new int[cap];
        front = 0;
        rear = 0;
    }

    // Add an element to the circular queue
    public void push(int n) {
        if ((rear + 1) % cap == front) {
            System.out.println("QUEUE IS FULL");
        } else {
            rear = (rear + 1) % cap;
            cq[rear] = n;
        }
    }

    // Remove and return the front element
    public int pop() {
        if (front == rear) {
            return -9999; // queue is empty
        } else {
            front = (front + 1) % cap;
            return cq[front];
        }
    }

    // Display the elements in the circular queue
    public void show() {
        if (front == rear) {
            System.out.println("QUEUE IS EMPTY");
            return;
        }
        System.out.print("Queue elements: ");
        int i = (front + 1) % cap;
        while (i != (rear + 1) % cap) {
            System.out.print(cq[i] + " ");
            i = (i + 1) % cap;
        }
        System.out.println();
    }
}

/* The main () function is OPTIONAL */

public class Main {
    public static void main(String[] args) {
        CirQueue q = new CirQueue(5); // Queue size of 5

        q.push(10);
        q.push(20);
        q.push(30);
        q.push(40);
        q.push(50); // should show "QUEUE IS FULL" after this
        q.show();

        System.out.println("Popped: " + q.pop());
        System.out.println("Popped: " + q.pop());
        q.show();

        q.push(60);
        q.push(70); // should now be allowed
        q.show();
    }
}

Output

OUTPUT:
Queue elements: 10 20 30 40 50 
Popped: 10
Popped: 20
Queue elements: 30 40 50 
Queue elements: 30 40 50 60 70
Previous
Next