Queue Implementation Using Array 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 an array with the following operations:

1. Enqueue 10
2. Enqueue 20
3. Dequeue
4. Enqueue 30

What is the state of the queue after these operations?

DSA Javascript

class Queue {
  constructor() {
    this.items = [];
  }
  enqueue(element) {
    this.items.push(element);
  }
  dequeue() {
    if(this.items.length === 0) return null;
    return this.items.shift();
  }
  print() {
    return this.items.join(' -> ') + ' -> null';
  }
}

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

A 20 -> 30 -> null

B 10 -> 20 -> 30 -> null

C 30 -> null

D 10 -> 30 -> null

💡 Hint

Remember that dequeue removes the first element added.

After enqueueing 10 and 20, the queue is [10, 20]. Dequeue removes 10, leaving [20]. Enqueue 30 adds it to the end, resulting in [20, 30].

❓ Predict Output

intermediate

What error occurs when dequeue is called on an empty queue?

Given the queue implementation below, what is the output when dequeue is called on an empty queue?

DSA Javascript

class Queue {
  constructor() {
    this.items = [];
  }
  dequeue() {
    return this.items.shift();
  }
}

const q = new Queue();
console.log(q.dequeue());

A undefined

B null

C Error: Cannot read property 'shift' of undefined

D 0

💡 Hint

What does shift() return when called on an empty array?

Calling shift() on an empty array returns undefined, so dequeue returns undefined.

🧠 Conceptual

advanced

Why is using an array for queue dequeue inefficient?

In a queue implemented using an array, why can the dequeue operation be inefficient?

A Because arrays do not allow random access

B Because push() is slow when adding elements to the end

C Because arrays cannot store multiple data types

D Because shift() removes the first element and shifts all other elements, causing O(n) time complexity

💡 Hint

Think about what happens internally when removing the first element from an array.

Removing the first element with shift() causes all other elements to move one position left, which takes O(n) time.

❓ Predict Output

advanced

What is the queue state after multiple enqueues and dequeues?

Given the following operations on a queue implemented with an array, what is the final queue state?

Operations:
enqueue(5), enqueue(10), dequeue(), enqueue(15), dequeue(), enqueue(20), enqueue(25), dequeue()

DSA Javascript

class Queue {
  constructor() {
    this.items = [];
  }
  enqueue(element) {
    this.items.push(element);
  }
  dequeue() {
    if(this.items.length === 0) return null;
    return this.items.shift();
  }
  print() {
    return this.items.join(' -> ') + ' -> null';
  }
}

const q = new Queue();
q.enqueue(5);
q.enqueue(10);
q.dequeue();
q.enqueue(15);
q.dequeue();
q.enqueue(20);
q.enqueue(25);
q.dequeue();
console.log(q.print());

A 15 -> 20 -> 25 -> null

B 5 -> 10 -> 15 -> 20 -> 25 -> null

C 20 -> 25 -> null

D 10 -> 15 -> 20 -> 25 -> null

💡 Hint

Track each enqueue and dequeue step carefully.

After the operations, the queue contains [20, 25].

🧠 Conceptual

expert

What is the best way to optimize dequeue in array-based queue?

To optimize the dequeue operation in a queue implemented using an array, which approach is best?

A Use shift() method directly on the array for each dequeue

B Use two pointers (front and rear) to track positions without shifting elements

C Use a linked list instead of an array

D Reverse the array after each dequeue

💡 Hint

Think about avoiding shifting elements on every dequeue.

Using two pointers to track front and rear avoids shifting elements, making dequeue O(1).

Practice

1. What is the main characteristic of a queue data structure implemented using an array?

easy

A. It stores elements in sorted order

B. It follows Last-In-First-Out (LIFO) order

C. It follows First-In-First-Out (FIFO) order

D. It allows random access to elements

Solution

1. Step 1: Understand queue behavior

   A queue adds elements at the end and removes from the front, so the first element added is the first removed.

2. Step 2: Compare with options

   FIFO means First-In-First-Out, which matches queue behavior. LIFO is for stacks, random access is for arrays, and sorted order is unrelated.

3. Final Answer:

   It follows First-In-First-Out (FIFO) order -> Option C

4. Quick Check:

   Queue = FIFO [OK]

Hint: Queue always removes the oldest element first [OK]

Common Mistakes:

• Confusing queue with stack (LIFO)
• Thinking queue allows random access
• Assuming queue sorts elements automatically

2. Which of the following is the correct syntax to add an element `x` to the end of a queue implemented as an array named queue in JavaScript?

easy

A. queue.push(x);

B. queue.pop(x);

C. queue.shift(x);

D. queue.unshift(x);

Solution

1. Step 1: Identify method to add at end

   In JavaScript arrays, push() adds an element to the end of the array.

2. Step 2: Check other methods

   pop() removes from end, shift() removes from front, unshift() adds at front.

3. Final Answer:

   queue.push(x); -> Option A

4. Quick Check:

   push adds at end [OK]

Hint: Use push() to add at end of array [OK]

Common Mistakes:

• Using pop() which removes instead of adds
• Using shift() or unshift() incorrectly
• Confusing push() with unshift()

3. What will be the output of the following JavaScript code implementing a queue using an array?

const queue = [];
queue.push(10);
queue.push(20);
const removed = queue.shift();
queue.push(30);
console.log(queue);

medium

A. [10, 20, 30]

B. [20, 30]

C. [30, 20]

D. [10, 30]

Solution

1. Step 1: Trace queue operations

   Initially empty array. After push(10), queue = [10]. After push(20), queue = [10, 20].

2. Step 2: Remove first element with shift()

   shift() removes 10, so queue = [20]. Then push(30), queue = [20, 30].

3. Final Answer:

   [20, 30] -> Option B

4. Quick Check:

   After shift and push, queue = [20, 30] [OK]

Hint: shift() removes front, push() adds end [OK]

Common Mistakes:

• Thinking shift() removes from end
• Confusing order of elements after operations
• Assuming push adds at front

4. Identify the error in the following queue implementation using an array and suggest the fix:

const queue = [];
queue.push(1);
queue.push(2);
const removed = queue.pop();
console.log(queue);

medium

A. pop() removes from end; use shift() to remove from front

B. push() should be replaced with unshift()

C. pop() should be replaced with push()

D. No error; code works correctly

Solution

1. Step 1: Understand queue removal operation

   Queue removes elements from the front, but pop() removes from the end.

2. Step 2: Correct removal method

   Use shift() to remove the first element to maintain FIFO order.

3. Final Answer:

   pop() removes from end; use shift() to remove from front -> Option A

4. Quick Check:

   Queue removal = shift() [OK]

Hint: Use shift() to remove front element in queue [OK]

Common Mistakes:

• Using pop() which removes last element
• Confusing push() and unshift() roles
• Thinking pop() removes front element

5. Given a queue implemented as an array, how can you efficiently check if the queue is empty before removing an element to avoid errors?

medium

A. Check if queue.length > 1 before calling shift()

B. Check if queue[0] === undefined before calling pop()

C. Call shift() directly without checking

D. Check if queue.length === 0 before calling shift()

Solution

1. Step 1: Understand empty queue condition

   An empty queue has length 0, so no elements to remove.

2. Step 2: Safe removal check

   Check queue.length === 0 before calling shift() to avoid removing from empty array.

3. Final Answer:

   Check if queue.length === 0 before calling shift() -> Option D

4. Quick Check:

   Empty queue check = length === 0 [OK]

Hint: Always check length === 0 before removing [OK]

Common Mistakes:

• Checking wrong index for emptiness
• Calling shift() without checking length
• Checking length > 1 instead of 0