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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueue operations?

Consider a linked list queue initially empty. We enqueue 10, then 20, then 30. What is the printed 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;
  }

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

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
q.enqueue(30);
q.print();

A 10 -> 20 -> 30 -> null

B 30 -> 20 -> 10 -> null

C 10 -> 20 -> null

D 20 -> 30 -> null

💡 Hint

Remember, enqueue adds to the rear of the queue.

Enqueue adds elements at the rear. So after adding 10, 20, 30, the queue order is 10 at front, then 20, then 30 at rear.

❓ Predict Output

intermediate

What error occurs with incorrect enqueue code?

What error will this enqueue method cause when called on an empty queue? enqueue(value) { const newNode = new Node(value); this.rear.next = newNode; this.rear = newNode; if (!this.front) { this.front = newNode; } }

A No error, works fine

B ReferenceError: newNode is not defined

C TypeError: Cannot read property 'next' of null

D SyntaxError: Unexpected token

💡 Hint

Check what happens when rear is null and you try to access rear.next.

If the queue is empty, rear is null. Trying to access rear.next causes a TypeError because you can't access 'next' of null.

🧠 Conceptual

advanced

Why do we update rear pointer in enqueue?

In a linked list implementation of a queue, why is it necessary to update the rear pointer when enqueueing a new node?

A To keep track of the last node for efficient insertion at the end

B To remove the first node from the queue

C To reverse the linked list after each insertion

D To delete the front node when queue is full

💡 Hint

Think about where new nodes are added in a queue.

The rear pointer always points to the last node so we can add new nodes quickly at the end without traversing the whole list.

❓ Predict Output

advanced

What is the queue state after mixed enqueue and dequeue?

Given this queue code, what is printed after these operations? q.enqueue(5); q.enqueue(15); q.dequeue(); q.enqueue(25); q.print();

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 value = this.front.value;
    this.front = this.front.next;
    if (!this.front) this.rear = null;
    return value;
  }

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

const q = new Queue();

A null

B 5 -> 15 -> 25 -> null

C 25 -> null

D 15 -> 25 -> null

💡 Hint

Dequeue removes from front, enqueue adds at rear.

After enqueue 5 and 15, queue is 5 -> 15 -> null. Dequeue removes 5. Then enqueue 25 adds at rear. Final queue: 15 -> 25 -> null.

🧠 Conceptual

expert

What is the time complexity of enqueue in linked list queue?

What is the time complexity of the enqueue operation in a linked list implementation of a queue when we maintain both front and rear pointers?

A O(n) linear time

B O(1) constant time

C O(log n) logarithmic time

D O(n^2) quadratic time

💡 Hint

Think about how rear pointer helps insertion.

With rear pointer, enqueue adds new node directly at the end in constant time without traversal.

Practice

1. What does the enqueue operation do in a queue implemented using a linked list?

easy

A. Deletes the entire linked list

B. Removes an element from the front (head) of the linked list

C. Adds a new element at the end (tail) of the linked list

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

Solution

1. Step 1: Understand enqueue operation

   Enqueue means adding an element to the queue.

2. Step 2: Identify position in linked list

   In a linked list queue, new elements are added at the tail (end).

3. Final Answer:

   Adds a new element at the end (tail) of the linked list -> Option C

4. Quick Check:

   Enqueue = add at tail [OK]

Hint: Enqueue always adds at the tail in linked list queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue operation
• Adding new element at the head instead of tail
• Thinking enqueue removes elements

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

easy

A. const node = { value: val, next: null };

B. const node = new Node(val); node.next = val;

C. const node = { val: value, next: undefined };

D. const node = Node(val, null);

Solution

1. Step 1: Understand node structure

   A node should have a value and a pointer to next (null initially).

2. Step 2: Check syntax correctness

   const node = { value: val, next: null }; correctly creates an object with value and next set to null.

3. Final Answer:

   const node = { value: val, next: null }; -> Option A

4. Quick Check:

   Node = {{value, next:null}} [OK]

Hint: Node must have value and next=null for enqueue [OK]

Common Mistakes:

• Using wrong property names like 'val' instead of 'value'
• Setting next to undefined instead of null
• Calling Node as a function without new keyword

3. What will be the state of the queue after these operations?

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

Assuming an empty queue initially, what is the linked list representation?

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

   Queue is empty, so 10 becomes head and tail: 10 -> null

2. Step 2: Enqueue 20 and 30

   20 added at tail: 10 -> 20 -> null, then 30 added: 10 -> 20 -> 30 -> null

3. Final Answer:

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

4. Quick Check:

   Order preserved, enqueue adds at tail [OK]

Hint: Enqueue adds at tail, order stays same [OK]

Common Mistakes:

• Reversing order of elements
• Confusing head and tail positions
• Assuming enqueue adds at head

4. Consider this enqueue function snippet:

function enqueue(val) {
  const node = { value: val, next: null };
  if (!this.tail) {
    this.head = node;
  }
  this.tail.next = node;
  this.tail = node;
}

What error will occur when enqueue is called on an empty queue?

medium

A. ReferenceError: this is not defined

B. SyntaxError: Unexpected token

C. No error, works fine

D. TypeError: Cannot read property 'next' of null

Solution

1. Step 1: Analyze empty queue condition

   When queue is empty, this.tail is null or undefined.

2. Step 2: Identify error line

   Code tries this.tail.next = node; but this.tail is null, causing TypeError.

3. Final Answer:

   TypeError: Cannot read property 'next' of null -> Option D

4. Quick Check:

   Accessing next on null causes TypeError [OK]

Hint: Check if tail exists before accessing next [OK]

Common Mistakes:

• Ignoring null check for tail
• Assuming no error on empty queue
• Confusing this.head and this.tail usage

5. You want to implement enqueue in a linked list queue that keeps track of both head and tail. Which of these code snippets correctly enqueues a new value val?

hard

A. const node = { value: val, next: null };
this.tail.next = node;
this.tail = node;

B. const node = { value: val, next: null };
if (!this.head) {
this.head = node;
this.tail = node;
} else {
this.tail.next = node;
this.tail = node;
}

C. const node = { value: val, next: this.head };
this.head = node;

D. const node = { value: val, next: null };
this.head.next = node;
this.head = node;

Solution

1. Step 1: Handle empty queue case

   If head is null, both head and tail should point to new node.

2. Step 2: Handle non-empty queue

   Set tail.next to new node and update tail to new node.

3. Final Answer:

   const node = { value: val, next: null }; if (!this.head) { this.head = node; this.tail = node; } else { this.tail.next = node; this.tail = node; } -> Option B

4. Quick Check:

   Check empty and non-empty cases for enqueue [OK]

Hint: Set head and tail on empty, else add at tail.next [OK]

Common Mistakes:

• Not updating tail on empty queue
• Adding new node at head instead of tail
• Forgetting to update tail pointer