Enqueue Using Linked List in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueue operations?

Consider a linked list based queue initially empty. We enqueue elements 5, 10, and 15 in this order. What is the printed state of the queue after these operations?

DSA Java

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

class Queue {
    Node front, rear;

    void enqueue(int value) {
        Node newNode = new Node(value);
        if (rear == null) {
            front = rear = newNode;
            return;
        }
        rear.next = newNode;
        rear = newNode;
    }

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

public class Main {
    public static void main(String[] args) {
        Queue q = new Queue();
        q.enqueue(5);
        q.enqueue(10);
        q.enqueue(15);
        q.printQueue();
    }
}

A 5 -> 10 -> 15 -> null

B 15 -> 10 -> 5 -> null

C 5 -> 10 -> null

D 10 -> 15 -> null

💡 Hint

Remember, enqueue adds elements at the rear of the queue.

Enqueue adds elements at the rear. So the order is 5, then 10, then 15. The print shows from front to rear.

❓ Predict Output

intermediate

What happens if we enqueue into an empty queue?

Given the enqueue method below, what will be the state of the queue after enqueueing the value 20 into an empty queue?

DSA Java

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

class Queue {
    Node front, rear;

    void enqueue(int value) {
        Node newNode = new Node(value);
        if (rear == null) {
            front = rear = newNode;
            return;
        }
        rear.next = newNode;
        rear = newNode;
    }

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

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

A null

B 20 -> null

C 0 -> 20 -> null

D 20 -> 20 -> null

💡 Hint

Check how front and rear are set when the queue is empty.

When the queue is empty, both front and rear point to the new node with value 20.

🔧 Debug

advanced

Identify the error in enqueue method

What error will occur when running this enqueue method on an empty queue?

DSA Java

void enqueue(int value) {
    Node newNode = new Node(value);
    if (front == null) {
        rear = newNode;
        return;
    }
    rear.next = newNode;
    rear = newNode;
}

A Syntax error due to missing semicolon

B NullPointerException when accessing rear.next

C No error, works correctly

D The front pointer remains null causing printQueue to fail or show empty queue

💡 Hint

Check if front is updated when queue is empty.

When queue is empty, front should also point to newNode. Here it is not set, so front remains null.

🧠 Conceptual

advanced

Why is rear pointer needed in linked list queue?

In a linked list implementation of a queue, why do we maintain a rear pointer along with front pointer?

A To allow enqueue operation in O(1) time by adding at the end directly

B To allow dequeue operation in O(1) time by removing from the end

C To keep track of the middle element for faster access

D To reverse the queue easily

💡 Hint

Think about where enqueue adds new elements.

Rear pointer lets us add new nodes at the end quickly without traversing the whole list.

❓ Predict Output

expert

Output after mixed enqueue and dequeue operations

Given the following sequence of operations on an initially empty linked list queue, what is the printed queue state? Operations: - enqueue(7) - enqueue(14) - dequeue() - enqueue(21) - enqueue(28) - dequeue() - enqueue(35) Assume dequeue removes from front and printQueue prints from front to rear.

DSA Java

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

class Queue {
    Node front, rear;

    void enqueue(int value) {
        Node newNode = new Node(value);
        if (rear == null) {
            front = rear = newNode;
            return;
        }
        rear.next = newNode;
        rear = newNode;
    }

    void dequeue() {
        if (front == null) return;
        front = front.next;
        if (front == null) rear = null;
    }

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

public class Main {
    public static void main(String[] args) {
        Queue q = new Queue();
        q.enqueue(7);
        q.enqueue(14);
        q.dequeue();
        q.enqueue(21);
        q.enqueue(28);
        q.dequeue();
        q.enqueue(35);
        q.printQueue();
    }
}

A 14 -> 21 -> 28 -> 35 -> null

B 7 -> 14 -> 21 -> 28 -> 35 -> null

C 21 -> 28 -> 35 -> null

D 21 -> 28 -> null

💡 Hint

Track front and rear carefully after each dequeue and enqueue.

After first dequeue, 7 is removed, front is 14. After second dequeue, 14 is removed, front is 21. Enqueues add at rear.

Practice

1. What does the enqueue operation do in a linked list implementation of a queue?

easy

A. Adds an element at the end (rear) of the linked list

B. Removes an element from the front of the linked list

C. Deletes the entire linked list

D. Adds an element at the front (head) of the linked list

Solution

1. Step 1: Understand enqueue operation in queue

   Enqueue means adding an element to the queue, which is done at the rear end.

2. Step 2: Linked list enqueue adds at the rear

   In linked list, adding at the rear means inserting the new node at the end of the list.

3. Final Answer:

   Adds an element at the end (rear) of the linked list -> Option A

4. Quick Check:

   Enqueue = add at rear [OK]

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

Common Mistakes:

• Confusing enqueue with dequeue operation
• Thinking enqueue adds at the front
• Mixing linked list head and tail roles

2. Which of the following is the correct way to create a new node for enqueue in Java linked list?

easy

A. Node newNode = new Node(); newNode.data = value; newNode.next = null;

B. Node newNode = Node(value); newNode.next = null;

C. Node newNode = new Node(value); newNode.next = null;

D. Node newNode = new Node; newNode.data = value;

Solution

1. Step 1: Understand Java object creation syntax

   In Java, to create an object with a constructor that takes a value, use new Node(value).

2. Step 2: Check next pointer initialization

   After creating the node, set next to null to mark end of list.

3. Final Answer:

   Node newNode = new Node(value); newNode.next = null; -> Option C

4. Quick Check:

   Java new object with constructor = new Node(value) [OK]

Hint: Use 'new' keyword with constructor for object creation [OK]

Common Mistakes:

• Missing 'new' keyword when creating object
• Incorrect constructor call syntax
• Not setting next pointer to null

3. What will be the state of the queue after the following enqueue operations on an empty linked list queue?

enqueue(10); enqueue(20); enqueue(30);

medium

A. 10 -> 20 -> 30 -> null

B. 30 -> 20 -> 10 -> null

C. null -> 10 -> 20 -> 30

D. 20 -> 10 -> 30 -> null

Solution

1. Step 1: Enqueue 10 on empty queue

   Queue becomes: 10 -> null

2. Step 2: Enqueue 20 and 30 sequentially

   After enqueue(20): 10 -> 20 -> null
   After enqueue(30): 10 -> 20 -> 30 -> null

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option A

4. Quick Check:

   Enqueue adds at rear, order preserved [OK]

Hint: Enqueue adds at rear, so order is insertion order [OK]

Common Mistakes:

• Reversing order of elements after enqueue
• Confusing enqueue with push (stack)
• Assuming new elements added at front

4. Identify the error in the following enqueue method for a linked list queue:

void enqueue(int value) {
  Node newNode = new Node(value);
  if (rear == null) {
    front = newNode;
  } else {
    rear.next = newNode;
  }
}

medium

A. Should set front.next to newNode instead of rear.next

B. Missing update of rear pointer to newNode

C. New node should be created with next pointing to front

D. Should check if front is null instead of rear

Solution

1. Step 1: Analyze enqueue logic

   When queue is empty, front is set to newNode but rear is not updated.

2. Step 2: Check rear pointer update

   After adding newNode, rear should point to newNode to keep track of last element.

3. Final Answer:

   Missing update of rear pointer to newNode -> Option B

4. Quick Check:

   Rear must always point to last node [OK]

Hint: Always update rear to new node after enqueue [OK]

Common Mistakes:

• Forgetting to update rear pointer
• Updating front.next instead of rear.next
• Not handling empty queue case properly

5. Given a linked list queue with elements 5 -> 15 -> 25 -> null, what will be the queue state after enqueueing 35 and then dequeueing one element?

hard

A. 35 -> 15 -> 25 -> null

B. 5 -> 15 -> 25 -> 35 -> null

C. 25 -> 35 -> null

D. 15 -> 25 -> 35 -> null

Solution

1. Step 1: Enqueue 35 at rear

   Queue becomes: 5 -> 15 -> 25 -> 35 -> null

2. Step 2: Dequeue removes front element 5

   After dequeue: 15 -> 25 -> 35 -> null

3. Final Answer:

   15 -> 25 -> 35 -> null -> Option D

4. Quick Check:

   Enqueue adds rear, dequeue removes front [OK]

Hint: Enqueue rear, dequeue front; order shifts accordingly [OK]

Common Mistakes:

• Removing wrong element on dequeue
• Adding new element at front instead of rear
• Not updating front pointer after dequeue