Enqueue Using Linked List in DSA Java - Build from Scratch

Enqueue Using Linked List

📖 Scenario: Imagine you are managing a line of customers waiting to buy tickets. Each new customer joins the end of the line. We will use a linked list to represent this line and add new customers to the end.

🎯 Goal: Build a simple linked list to represent a queue and add new elements to the end using the enqueue operation.

📋 What You'll Learn

Create a Node class with an integer data field and a next pointer

Create a Queue class with front and rear pointers

Implement an enqueue method to add elements at the rear

Print the queue elements from front to rear after enqueue operations

💡 Why This Matters

🌍 Real World

Queues are used in real life to manage lines, like customers waiting in a store or tasks waiting to be processed by a computer.

💼 Career

Understanding how to implement queues with linked lists is important for software developers working on systems that require ordered processing, such as print queues, task schedulers, and network packet handling.

1

Create Node class and Queue class with front and rear

Create a Node class with an integer data field and a Node next pointer. Then create a Queue class with two Node variables called front and rear, both initialized to null.

DSA Java

// Define Node class
// Define Queue class with front and rear initialized to null
// Your code here

Hint

Start by defining a Node class with a constructor that sets data and next. Then define a Queue class with front and rear set to null.

2

Add enqueue method to Queue class

Inside the Queue class, add a method called enqueue that takes an integer value. This method should create a new Node with value. If rear is null, set both front and rear to the new node. Otherwise, set rear.next to the new node and update rear to the new node.

DSA Java

class Node {
    int data;
    Node next;

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

class Queue {
    Node front;
    Node rear;

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

    // Add enqueue method here
    // Your code here
}

Hint

Check if rear is null. If yes, set both front and rear to the new node. Otherwise, link the new node at the end and update rear.

3

Add method to print queue elements

Add a method called printQueue inside the Queue class. This method should start from front and print each node's data followed by -> until it reaches null. After the last node, print null.

DSA Java

class Node {
    int data;
    Node next;

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

class Queue {
    Node front;
    Node rear;

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

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

    // Add printQueue method here
    // Your code here
}

Hint

Use a temporary node starting at front. Loop until it is null, printing data and arrow. After loop, print null.

4

Enqueue elements and print the queue

In the main method, create a Queue object called queue. Enqueue the integers 10, 20, and 30 in this order. Then call queue.printQueue() to display the queue.

DSA Java

class Node {
    int data;
    Node next;

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

class Queue {
    Node front;
    Node rear;

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

    void enqueue(int value) {
        Node newNode = new Node(value);
        if (rear == null) {
            front = newNode;
            rear = newNode;
        } else {
            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\n");
    }
}

public class Main {
    public static void main(String[] args) {
        // Your code here
    }
}

Hint

Create a Queue object, add 10, 20, and 30 using enqueue, then print the queue.

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