Enqueue Using Linked List in DSA Java - Execution Trace

Concept Flow - Enqueue Using Linked List

Create new node with data

↓

Is queue empty?

Yes→Set head and tail to new node

No↓

Set tail.next to new node

↓

Update tail to new node

↓

Done

Shows how a new node is created and added at the end of the linked list representing the queue.

Execution Sample

DSA Java

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

class Queue {
  Node head;
  Node tail;

  void enqueue(int val) {
    Node newNode = new Node(val);
    if (tail == null) {
      head = tail = newNode;
    } else {
      tail.next = newNode;
      tail = newNode;
    }
  }
}

Adds a new element at the end of the queue using linked list pointers.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create new node with data=10	None	newNode created	null
2	Check if queue empty (tail == null)	None	tail is null	null
3	Set head and tail to newNode	10	head -> newNode, tail -> newNode	10 -> null
4	Create new node with data=20	10	newNode created	10 -> null
5	Check if queue empty (tail == null)	10	tail not null	10 -> null
6	Set tail.next to newNode	10, 20	tail.next -> newNode	10 -> 20 -> null
7	Update tail to newNode	10, 20	tail -> newNode	10 -> 20 -> null
8	Create new node with data=30	10, 20	newNode created	10 -> 20 -> null
9	Check if queue empty (tail == null)	10, 20	tail not null	10 -> 20 -> null
10	Set tail.next to newNode	10, 20, 30	tail.next -> newNode	10 -> 20 -> 30 -> null
11	Update tail to newNode	10, 20, 30	tail -> newNode	10 -> 20 -> 30 -> null
12	End of enqueue operations	10, 20, 30	head -> 10, tail -> 30	10 -> 20 -> 30 -> null

💡 All enqueue operations completed; queue updated with new nodes at tail.

Variable Tracker

Variable	Start	After Step 3	After Step 7	After Step 11	Final
head	null	Node(10)	Node(10)	Node(10)	Node(10)
tail	null	Node(10)	Node(20)	Node(30)	Node(30)
newNode	null	Node(10)	Node(20)	Node(30)	Node(30)
Linked List Size	0	1	2	3	3

Key Moments - 3 Insights

Why do we check if tail is null before adding a new node?

Because if tail is null, the queue is empty, so both head and tail must point to the new node (see step 2 and 3 in execution_table).

Why do we update tail.next before moving tail to newNode?

Updating tail.next links the old last node to the new node, maintaining the chain (see step 6). Then tail moves to newNode to mark the new end (step 7).

What happens if we forget to update tail after adding newNode?

The tail pointer would still point to the old last node, causing incorrect enqueue behavior and breaking the queue structure (not shown but implied after step 6).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does the queue look like?

A null

B 10 -> null

C 20 -> null

D 10 -> 20 -> null

💡 Hint

Check the Visual State column at step 3 in execution_table.

At which step does the tail pointer first move from Node(10) to Node(20)?

A Step 7

B Step 3

C Step 6

D Step 10

💡 Hint

Look at Pointer Changes and tail updates in execution_table rows.

If we enqueue a new node with data=40 after step 11, what will be the new tail's data?

A 30

B 20

C 40

D 10

💡 Hint

Refer to variable_tracker for tail after new enqueue operations.

Concept Snapshot

Enqueue Using Linked List:
- Create new node with data
- If queue empty (tail == null), set head and tail to new node
- Else, set tail.next to new node
- Update tail to new node
- New node is always added at the end
- Maintains FIFO order

Full Transcript

This visualization shows how to add elements to a queue implemented with a linked list. We create a new node for each value. If the queue is empty, both head and tail point to this new node. Otherwise, the current tail's next pointer links to the new node, and tail moves to this new node. This keeps the queue order correct, adding new elements at the end. The execution table tracks each step, showing how nodes and pointers change. The variable tracker shows head, tail, and newNode pointers and the list size after each operation. Key moments clarify why we check for empty queue and why updating tail is important. The quiz tests understanding of queue state at different steps.

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