Enqueue Operation in DSA Java

Mental Model

Adding a new item to the end of a line so it waits its turn.

Analogy: Imagine people standing in a queue at a ticket counter. When a new person arrives, they join at the back of the line, not in the middle or front.

front -> 1 -> 2 -> 3 -> null
rear ↑

Dry Run Walkthrough

Input: queue: 1 -> 2 -> 3 -> null, enqueue value 4

Goal: Add the value 4 at the end of the queue

Step 1: Create a new node with value 4

front -> 1 -> 2 -> 3 -> null
rear ↑
newNode: 4 -> null

Why: We need a new node to hold the value before adding it to the queue

Step 2: Link the current rear node (3) to the new node (4)

front -> 1 -> 2 -> 3 -> [rear->4] -> null

Why: The new node must be connected at the end of the queue

Step 3: Update rear pointer to the new node (4)

front -> 1 -> 2 -> 3 -> 4 -> null
rear ↑

Why: Rear must always point to the last node in the queue

Result:

front -> 1 -> 2 -> 3 -> 4 -> null
rear ↑

Annotated Code

DSA Java

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class Queue {
    Node front, rear;

    Queue() {
        this.front = null;
        this.rear = null;
    }

    void enqueue(int value) {
        Node newNode = new Node(value); // create new node
        if (rear == null) { // queue empty
            front = rear = newNode; // front and rear point to new node
            return;
        }
        rear.next = newNode; // link new node at end
        rear = newNode; // update rear to new node
    }

    void printQueue() {
        Node temp = front;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }
}

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); // enqueue value 4
        q.printQueue();
    }
}

Node newNode = new Node(value); // create new node

create a new node to hold the value

if (rear == null) { // queue empty front = rear = newNode; // front and rear point to new node return; }

handle empty queue by setting front and rear to new node

rear.next = newNode; // link new node at end

connect new node after current rear

rear = newNode; // update rear to new node

move rear pointer to new last node

Output

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

Complexity Analysis

Time: O(1) because we add the new node directly at the rear without traversing

Space: O(1) because only one new node is created regardless of queue size

vs Alternative: Compared to adding at front or traversing to end (O(n)), enqueue at rear is faster and more efficient

Edge Cases

empty queue

front and rear both point to the new node

DSA Java

if (rear == null) { front = rear = newNode; return; }

When to Use This Pattern

When you see a problem asking to add items in order and remove in the same order, think of enqueue operation to add at the end of a queue.

Common Mistakes

Mistake: Not updating the rear pointer after adding the new node
Fix: Always set rear = newNode after linking the new node

Mistake: Not handling the empty queue case where front and rear are null
Fix: Check if rear is null and set both front and rear to new node

Summary

Adds a new element at the end of the queue.

Use when you want to insert items in a first-in-first-out order.

Remember to update the rear pointer and handle the empty queue case.

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