Enqueue Operation in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Enqueue in Circular Queue

What is the printed state of the circular queue after these enqueue operations?

DSA Java

class CircularQueue {
    int[] arr;
    int front, rear, size, capacity;

    CircularQueue(int capacity) {
        this.capacity = capacity;
        arr = new int[capacity];
        front = 0;
        rear = -1;
        size = 0;
    }

    void enqueue(int x) {
        if (size == capacity) return;
        rear = (rear + 1) % capacity;
        arr[rear] = x;
        size++;
    }

    void printQueue() {
        for (int i = 0; i < size; i++) {
            System.out.print(arr[(front + i) % capacity] + " -> ");
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        CircularQueue q = new CircularQueue(4);
        q.enqueue(10);
        q.enqueue(20);
        q.enqueue(30);
        q.enqueue(40);
        q.printQueue();
    }
}

A null

B 40 -> 30 -> 20 -> 10 -> null

C 10 -> 20 -> 30 -> 40 -> null

D 10 -> 20 -> 30 -> null

💡 Hint

Remember that enqueue adds elements at the rear and the queue prints from front to rear.

The enqueue method adds elements in order at the rear index, wrapping around if needed. Since the queue capacity is 4 and we add 4 elements, all are stored in order. The printQueue method prints from front to rear, so output is 10 -> 20 -> 30 -> 40 -> null.

❓ Predict Output

intermediate

Result of Enqueue When Queue is Full

What will be the output after trying to enqueue an element into a full queue?

DSA Java

class Queue {
    int[] arr;
    int front, rear, size, capacity;

    Queue(int capacity) {
        this.capacity = capacity;
        arr = new int[capacity];
        front = 0;
        rear = -1;
        size = 0;
    }

    void enqueue(int x) {
        if (size == capacity) {
            System.out.println("Queue is full");
            return;
        }
        rear++;
        arr[rear] = x;
        size++;
    }

    void printQueue() {
        for (int i = front; i <= rear; i++) {
            System.out.print(arr[i] + " -> ");
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        Queue q = new Queue(3);
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        q.enqueue(4);
        q.printQueue();
    }
}

A

Queue is full
1 -> 2 -> 3 -> null

B 1 -> 2 -> 3 -> 4 -> null

C

Queue is full
null

D 1 -> 2 -> null

💡 Hint

Check the condition that prevents adding when the queue is full.

The queue capacity is 3. After adding 3 elements, the queue is full. The fourth enqueue prints "Queue is full" and does not add the element. The printQueue method prints the existing 3 elements.

🔧 Debug

advanced

Identify the Bug in Enqueue Method

What error will occur when running this enqueue method?

DSA Java

class Queue {
    int[] arr = new int[3];
    int rear = 0;
    int size = 0;
    int capacity = 3;

    void enqueue(int x) {
        if (size == capacity) {
            System.out.println("Full");
            return;
        }
        arr[rear] = x;
        rear++;
        size++;
    }
}

public class Main {
    public static void main(String[] args) {
        Queue q = new Queue();
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        q.enqueue(4);
    }
}

A ArrayIndexOutOfBoundsException

B Compilation error

C NullPointerException

D No error, prints "Full" once

💡 Hint

Check how rear index changes and array size.

No error occurs. The `if (size == capacity)` check prevents overflow. After three enqueues, `size` is 3 and `rear` is 3. The fourth enqueue prints "Full" and returns before assigning to `arr[rear]`, avoiding ArrayIndexOutOfBoundsException.

❓ Predict Output

advanced

Output After Multiple Enqueues and Wrap Around

What is the printed queue after these operations on a circular queue of capacity 5?

DSA Java

class CircularQueue {
    int[] arr;
    int front, rear, size, capacity;

    CircularQueue(int capacity) {
        this.capacity = capacity;
        arr = new int[capacity];
        front = 0;
        rear = -1;
        size = 0;
    }

    void enqueue(int x) {
        if (size == capacity) return;
        rear = (rear + 1) % capacity;
        arr[rear] = x;
        size++;
    }

    void dequeue() {
        if (size == 0) return;
        front = (front + 1) % capacity;
        size--;
    }

    void printQueue() {
        for (int i = 0; i < size; i++) {
            System.out.print(arr[(front + i) % capacity] + " -> ");
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        CircularQueue q = new CircularQueue(5);
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        q.enqueue(4);
        q.enqueue(5);
        q.dequeue();
        q.dequeue();
        q.enqueue(6);
        q.enqueue(7);
        q.printQueue();
    }
}

A 1 -> 2 -> 3 -> 4 -> 5 -> null

B 3 -> 4 -> 5 -> 6 -> 7 -> null

C 6 -> 7 -> 3 -> 4 -> 5 -> null

D null

💡 Hint

Remember dequeue moves front forward and enqueue wraps rear index.

After enqueuing 1 to 5, queue is full. Dequeue twice removes 1 and 2, so front moves forward. Enqueue 6 and 7 wrap rear index to start. The queue now contains 3,4,5,6,7 in order.

🧠 Conceptual

expert

Maximum Number of Enqueue Operations Before Full

Given a queue implemented with an array of capacity N, starting empty, how many enqueue operations can be performed before the queue is full?

A N

B N-1

C N+1

D 2*N

💡 Hint

Consider that the queue size cannot exceed its capacity.

A queue with capacity N can hold exactly N elements. Starting empty, you can enqueue N times before it becomes full.

Practice

1. What does the enqueue operation do in a queue data structure?

easy

A. Adds an element to the end of the queue

B. Removes an element from the front of the queue

C. Checks if the queue is empty

D. Returns the size of the queue

Solution

1. Step 1: Understand the queue structure

   A queue works like a line where elements are added at the back and removed from the front.

2. Step 2: Define enqueue operation

   Enqueue means adding a new element at the end of the queue to wait its turn.

3. Final Answer:

   Adds an element to the end of the queue -> Option A

4. Quick Check:

   Enqueue = Add at end [OK]

Hint: Enqueue always adds at the back of the queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue
• Thinking enqueue removes elements
• Mixing enqueue with checking size

2. Which of the following is the correct Java syntax to enqueue an element 5 into a queue named q?

easy

A. q.enqueue(5);

B. q.add(5);

C. q.push(5);

D. q.insert(5);

Solution

1. Step 1: Recall Java Queue methods

   Java's Queue interface uses add() or offer() to enqueue elements.

2. Step 2: Identify correct method

   enqueue() and insert() are not standard Queue methods; push() is for stacks.

3. Final Answer:

   q.add(5); -> Option B

4. Quick Check:

   Java Queue enqueue = add() [OK]

Hint: Use add() to enqueue in Java Queue [OK]

Common Mistakes:

• Using push() which is for stacks
• Using enqueue() which is not a Java Queue method
• Using insert() which doesn't exist in Queue

3. What will be the output of the following Java code snippet?

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

public class TestQueue {
  public static void main(String[] args) {
    Queue<Integer> q = new LinkedList<>();
    q.add(10);
    q.add(20);
    q.add(30);
    q.add(40);
    q.add(50);
    q.add(60);
    System.out.println(q);
  }
}

medium

A. [10 -> 20 -> 30 -> 40 -> 50 -> 60 -> null]

B. [60, 50, 40, 30, 20, 10]

C. SyntaxError

D. [10, 20, 30, 40, 50, 60]

Solution

1. Step 1: Understand Queue implementation

   LinkedList implements Queue and stores elements in insertion order.

2. Step 2: Trace enqueue operations

   Elements 10, 20, 30, 40, 50, 60 are added in that order, so printing the queue shows them in the same order.

3. Final Answer:

   [10, 20, 30, 40, 50, 60] -> Option D

4. Quick Check:

   Queue prints elements in insertion order [OK]

Hint: Queue prints elements in order added [OK]

Common Mistakes:

• Assuming reverse order print
• Expecting arrow notation in output
• Thinking code has syntax errors

4. Identify the error in the following Java code that tries to enqueue an element into a queue:

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

public class QueueTest {
  public static void main(String[] args) {
    Queue<Integer> q = new LinkedList<>();
    q.enqueue(100);
    System.out.println(q);
  }
}

medium

A. Cannot print queue directly

B. LinkedList cannot be used as a Queue

C. Queue interface has no method named enqueue()

D. Missing import for enqueue method

Solution

1. Step 1: Check Queue interface methods

   Java's Queue interface does not have an enqueue() method; it uses add() or offer().

2. Step 2: Verify LinkedList usage

   LinkedList implements Queue correctly, so no issue there; printing queue directly works fine.

3. Final Answer:

   Queue interface has no method named enqueue() -> Option C

4. Quick Check:

   enqueue() method missing in Queue [OK]

Hint: Use add() or offer() to enqueue in Java Queue [OK]

Common Mistakes:

• Trying to call enqueue() on Java Queue
• Thinking LinkedList can't be a Queue
• Assuming enqueue is a standard method

5. You have a queue implemented using a linked list with a fixed maximum size of 3. What will happen if you try to enqueue a fourth element without dequeuing any element first?

hard

A. The enqueue operation will fail or throw an error due to overflow

B. The new element will be added, increasing the queue size beyond 3

C. The oldest element will be removed automatically to add the new element

D. The queue will reset and start empty before adding the new element

Solution

1. Step 1: Understand fixed size queue behavior

   A fixed size queue cannot hold more elements than its maximum capacity.

2. Step 2: Effect of enqueue beyond capacity

   Trying to add a fourth element when size is 3 causes overflow; enqueue fails or throws an error.

3. Final Answer:

   The enqueue operation will fail or throw an error due to overflow -> Option A

4. Quick Check:

   Fixed size queue overflow blocks enqueue [OK]

Hint: Fixed size queue blocks enqueue when full [OK]

Common Mistakes:

• Assuming queue auto-removes oldest element
• Thinking queue size can grow unlimited
• Believing queue resets automatically