Queue Implementation Using Linked List in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueue and dequeue operations?

Consider a queue implemented using a linked list. Initially, the queue is empty. We perform the following operations:
enqueue(10), enqueue(20), dequeue(), enqueue(30), dequeue()
What is the state of the queue after these operations?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

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

  enqueue(value) {
    const newNode = new Node(value);
    if (!this.rear) {
      this.front = this.rear = newNode;
      return;
    }
    this.rear.next = newNode;
    this.rear = newNode;
  }

  dequeue() {
    if (!this.front) return null;
    const temp = this.front;
    this.front = this.front.next;
    if (!this.front) this.rear = null;
    return temp.value;
  }

  printQueue() {
    let current = this.front;
    let result = '';
    while (current) {
      result += current.value + ' -> ';
      current = current.next;
    }
    return result + 'null';
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
q.dequeue();
q.enqueue(30);
q.dequeue();
console.log(q.printQueue());

A null

B 10 -> 30 -> null

C 20 -> 30 -> null

D 30 -> null

💡 Hint

Trace each operation step-by-step and see which nodes remain in the queue.

After enqueue(10) and enqueue(20), queue is 10 -> 20 -> null. dequeue() removes 10, queue becomes 20 -> null. enqueue(30) adds 30 at rear, queue is 20 -> 30 -> null. dequeue() removes 20, queue becomes 30 -> null.

🧠 Conceptual

intermediate

What happens when dequeue is called on an empty queue?

In a queue implemented using a linked list, what is the expected behavior when the dequeue operation is called but the queue is empty?

A Returns null or equivalent to indicate the queue is empty

B Throws a runtime error and stops the program

C Removes the last element from the queue

D Adds a new node with value null to the queue

💡 Hint

Think about safe handling of empty data structures.

When dequeue is called on an empty queue, it should safely return null or a similar value to indicate no elements are available, avoiding errors.

🔧 Debug

advanced

Identify the bug in this enqueue method

The following enqueue method is intended to add a new node to the rear of the queue. What is the bug that will cause incorrect behavior?

DSA Javascript

enqueue(value) {
  const newNode = new Node(value);
  if (!this.front) {
    this.front = newNode;
  }
  this.rear.next = newNode;
  this.rear = newNode;
}

A It does not set rear when queue is empty, causing rear.next to fail

B It adds newNode at front instead of rear

C It sets front but never updates rear, so rear remains null

D It creates a circular linked list by linking rear to front

💡 Hint

Consider what happens when the queue is empty and rear is null.

When the queue is empty, rear is null, so accessing rear.next causes an error. The code should set both front and rear to newNode in this case.

❓ Predict Output

advanced

What is the output after multiple enqueue and dequeue?

Given the following operations on an empty queue:
enqueue(5), enqueue(15), enqueue(25), dequeue(), enqueue(35), dequeue(), dequeue()
What is the printed state of the queue?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

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

  enqueue(value) {
    const newNode = new Node(value);
    if (!this.rear) {
      this.front = this.rear = newNode;
      return;
    }
    this.rear.next = newNode;
    this.rear = newNode;
  }

  dequeue() {
    if (!this.front) return null;
    const temp = this.front;
    this.front = this.front.next;
    if (!this.front) this.rear = null;
    return temp.value;
  }

  printQueue() {
    let current = this.front;
    let result = '';
    while (current) {
      result += current.value + ' -> ';
      current = current.next;
    }
    return result + 'null';
  }
}

const q = new Queue();
q.enqueue(5);
q.enqueue(15);
q.enqueue(25);
q.dequeue();
q.enqueue(35);
q.dequeue();
q.dequeue();
console.log(q.printQueue());

A 25 -> 35 -> null

B 15 -> 25 -> 35 -> null

C 35 -> null

D null

💡 Hint

Track each enqueue and dequeue carefully to see which nodes remain.

Operations:
enqueue(5), enqueue(15), enqueue(25) → queue: 5 -> 15 -> 25 -> null
dequeue() removes 5 → queue: 15 -> 25 -> null
enqueue(35) → queue: 15 -> 25 -> 35 -> null
dequeue() removes 15 → queue: 25 -> 35 -> null
dequeue() removes 25 → queue: 35 -> null
Final queue: 35 -> null

🧠 Conceptual

expert

Why is a linked list preferred over an array for queue implementation in some cases?

Which of the following is the main reason to use a linked list instead of an array to implement a queue?

A Arrays use more memory than linked lists for queues

B Linked lists allow constant time enqueue and dequeue without shifting elements

C Linked lists are easier to implement than arrays

D Arrays cannot be used to implement queues

💡 Hint

Think about what happens when you remove the first element from an array.

In arrays, dequeue requires shifting all elements which takes linear time. Linked lists allow adding/removing nodes at ends in constant time without shifting.

Practice

1. What is the main advantage of implementing a Queue using a linked list instead of an array?

easy

A. Simpler syntax for insertion and deletion

B. Faster random access to elements

C. Uses less memory than arrays

D. Dynamic size without fixed capacity limits

Solution

1. Step 1: Understand queue size limitations in arrays

   Arrays have fixed size or require resizing, which can be costly.

2. Step 2: Linked list dynamic size advantage

   Linked lists grow and shrink dynamically without fixed capacity limits.

3. Final Answer:

   Dynamic size without fixed capacity limits -> Option D

4. Quick Check:

   Linked list queues grow dynamically [OK]

Hint: Linked lists grow dynamically, arrays have fixed size [OK]

Common Mistakes:

• Thinking linked lists allow faster random access
• Assuming linked lists always use less memory
• Confusing syntax simplicity with performance

2. Which of the following is the correct way to add a new node to the end of a linked list queue in JavaScript?

easy

A. tail.next = newNode; tail = newNode;

B. head.next = newNode; head = newNode;

C. newNode.next = tail; tail = newNode;

D. newNode.next = head; head = newNode;

Solution

1. Step 1: Identify tail pointer usage in queue enqueue

   New nodes are added at the tail; tail.next points to new node.

2. Step 2: Update tail to new node

   After adding, tail must point to the new node to keep queue end updated.

3. Final Answer:

   tail.next = newNode; tail = newNode; -> Option A

4. Quick Check:

   Enqueue adds at tail [OK]

Hint: Enqueue adds at tail: tail.next = newNode; tail = newNode [OK]

Common Mistakes:

• Adding new node at head instead of tail
• Not updating tail pointer after insertion
• Confusing head and tail pointers

3. You want to implement a method peek() for a linked list queue that returns the front element without removing it. Which is the correct implementation?

easy

A. return this.head ? this.head.value : null;

B. return this.tail ? this.tail.value : null;

C. return this.head.next ? this.head.next.value : null;

D. return this.tail.next ? this.tail.next.value : null;

Solution

1. Step 1: Understand peek operation in queue

   Peek returns front element without removing it, which is at head in linked list queue.

2. Step 2: Check correct pointer for front element

   Head points to front node; tail points to end node. So return head.value if head exists.

3. Final Answer:

   return this.head ? this.head.value : null; -> Option A

4. Quick Check:

   Peek returns head value [OK]

Hint: Peek returns head value without dequeue [OK]

Common Mistakes:

• Returning tail value instead of head
• Accessing next of tail which is always null
• Returning head.next value which skips front

4. Consider this JavaScript code for a linked list queue:

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class Queue {
  constructor() {
    this.head = null;
    this.tail = null;
  }
  enqueue(value) {
    const newNode = new Node(value);
    if (!this.tail) {
      this.head = newNode;
      this.tail = newNode;
      return;
    }
    this.tail.next = newNode;
    this.tail = newNode;
  }
  dequeue() {
    if (!this.head) return null;
    const val = this.head.value;
    this.head = this.head.next;
    if (!this.head) this.tail = null;
    return val;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
q.dequeue();
q.enqueue(30);
q.dequeue();
q.enqueue(40);
q.enqueue(50);
q.dequeue();
console.log(q.head.value);

What will be printed?

medium

A. 20

B. 40

C. 50

D. 30

Solution

1. Step 1: Trace enqueue and dequeue operations

   Queue after operations: - enqueue 10: head=10, tail=10 - enqueue 20: head=10->20, tail=20 - dequeue: removes 10, head=20 - enqueue 30: head=20->30, tail=30 - dequeue: removes 20, head=30 - enqueue 40: head=30->40, tail=40 - enqueue 50: head=30->40->50, tail=50 - dequeue: removes 30, head=40

2. Step 2: Identify current head value

   After last dequeue, head points to node with value 40.

3. Final Answer:

   40 -> Option B

4. Quick Check:

   Final head value after operations = 40 [OK]

Hint: Track head after each dequeue to find current front [OK]

Common Mistakes:

• Forgetting to update tail when queue becomes empty
• Mixing up enqueue and dequeue order
• Assuming head value is unchanged after dequeue

5. The following dequeue method for a linked list queue has a bug:

dequeue() {
  if (!this.head) return null;
  const val = this.head.value;
  this.head = this.head.next;
  return val;
}

What is the problem?

medium

A. It removes the tail instead of the head

B. It returns the wrong value

C. It does not update tail when queue becomes empty

D. It causes infinite loop

Solution

1. Step 1: Analyze dequeue method behavior

   It removes head by moving head pointer to next node and returns old head value.

2. Step 2: Identify missing tail update

   If after removal head becomes null (queue empty), tail still points to old node causing inconsistency.

3. Final Answer:

   It does not update tail when queue becomes empty -> Option C

4. Quick Check:

   Empty queue must reset tail = null [OK]

Hint: Reset tail to null when head becomes null after dequeue [OK]

Common Mistakes:

• Ignoring tail pointer update on empty queue
• Confusing head and tail roles
• Assuming dequeue removes tail node