Dequeue Operation in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after multiple enqueue and dequeue operations

What is the state of the dequeue after executing the following operations in order?

DSA Typescript

class Dequeue {
  items: number[] = [];

  enqueueFront(element: number) {
    this.items.unshift(element);
  }

  enqueueRear(element: number) {
    this.items.push(element);
  }

  dequeueFront(): number | undefined {
    return this.items.shift();
  }

  dequeueRear(): number | undefined {
    return this.items.pop();
  }

  print(): string {
    return this.items.join(' -> ') + ' -> null';
  }
}

const dq = new Dequeue();
dq.enqueueRear(10);
dq.enqueueRear(20);
dq.enqueueFront(5);
dq.dequeueRear();
dq.enqueueFront(3);
dq.dequeueFront();
console.log(dq.print());

A 5 -> 10 -> null

B 3 -> 5 -> 10 -> null

C 5 -> 10 -> 20 -> null

D 10 -> null

💡 Hint

Trace each operation step-by-step, updating the dequeue contents.

Step-by-step:

• enqueueRear(10): [10]
• enqueueRear(20): [10, 20]
• enqueueFront(5): [5, 10, 20]
• dequeueRear(): removes 20 → [5, 10]
• enqueueFront(3): [3, 5, 10]
• dequeueFront(): removes 3 → [5, 10]

Final state: 5 -> 10 -> null

❓ Predict Output

intermediate

Result after dequeueFront on empty dequeue

What will be the output of the following code snippet?

DSA Typescript

class Dequeue {
  items: number[] = [];

  dequeueFront(): number | undefined {
    return this.items.shift();
  }
}

const dq = new Dequeue();
const result = dq.dequeueFront();
console.log(result);

A 0

B null

C undefined

D Throws an error

💡 Hint

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

The shift() method returns undefined if the array is empty. It does not throw an error or return null.

❓ Predict Output

advanced

Output after complex dequeue operations

What is the printed output after running this code?

DSA Typescript

class Dequeue {
  items: number[] = [];

  enqueueFront(element: number) {
    this.items.unshift(element);
  }

  enqueueRear(element: number) {
    this.items.push(element);
  }

  dequeueFront(): number | undefined {
    return this.items.shift();
  }

  dequeueRear(): number | undefined {
    return this.items.pop();
  }

  print(): string {
    return this.items.join(' -> ') + ' -> null';
  }
}

const dq = new Dequeue();
dq.enqueueRear(1);
dq.enqueueRear(2);
dq.enqueueFront(3);
dq.enqueueRear(4);
dq.dequeueFront();
dq.dequeueRear();
dq.enqueueFront(5);
console.log(dq.print());

A 5 -> 3 -> 1 -> 2 -> null

B 5 -> 1 -> 2 -> null

C 1 -> 2 -> null

D 3 -> 1 -> 2 -> 4 -> null

💡 Hint

Follow each enqueue and dequeue carefully, updating the list.

Operations step-by-step:

• enqueueRear(1): [1]
• enqueueRear(2): [1, 2]
• enqueueFront(3): [3, 1, 2]
• enqueueRear(4): [3, 1, 2, 4]
• dequeueFront(): removes 3 → [1, 2, 4]
• dequeueRear(): removes 4 → [1, 2]
• enqueueFront(5): [5, 1, 2]

Final state: 5 -> 1 -> 2 -> null

🧠 Conceptual

advanced

Understanding time complexity of dequeue operations

Which statement correctly describes the time complexity of enqueueFront and dequeueRear operations in a dequeue implemented with a doubly linked list?

A enqueueFront runs in O(1) time, dequeueRear runs in O(n) time because rear removal requires traversal.

B enqueueFront runs in O(n) time, dequeueRear runs in O(1) time because only rear removal is direct.

C Both enqueueFront and dequeueRear run in O(n) time because traversal is needed to find ends.

D Both enqueueFront and dequeueRear run in O(1) time because nodes can be added or removed directly at the ends.

💡 Hint

Think about how doubly linked lists store references to both ends.

In a doubly linked list, both front and rear nodes are directly accessible. Adding or removing nodes at either end is done by updating pointers, which takes constant time O(1).

🔧 Debug

expert

Identify the bug causing incorrect dequeueRear behavior

Consider this dequeue implementation. Which option correctly identifies the bug causing dequeueRear to remove from the front instead of the rear?

DSA Typescript

class Dequeue {
  items: number[] = [];

  enqueueRear(element: number) {
    this.items.push(element);
  }

  dequeueRear(): number | undefined {
    if (this.items.length === 0) {
      return undefined;
    }
    return this.items.shift();
  }
}

const dq = new Dequeue();
dq.enqueueRear(10);
dq.enqueueRear(20);
console.log(dq.dequeueRear());

A dequeueRear incorrectly uses shift() instead of pop(), removing from front instead of rear.

B dequeueRear does not check if items is empty before removing, causing runtime error.

C The items array is not initialized properly, causing dequeueRear to always return undefined.

D enqueueRear uses push() which adds to front, causing dequeueRear to fail.

💡 Hint

Check which method removes from the front and which from the rear in arrays.

The bug is that dequeueRear uses shift() which removes the first element (front), but it should use pop() to remove the last element (rear).

Practice

1. What is the main difference between a dequeue and a queue?

easy

A. A dequeue allows insertion and deletion from both ends.

B. A dequeue only allows insertion at the rear.

C. A dequeue only allows deletion from the front.

D. A dequeue is a fixed size data structure.

Solution

1. Step 1: Understand queue operations

   A queue allows insertion at the rear and deletion from the front only.

2. Step 2: Understand dequeue operations

   A dequeue allows insertion and deletion at both front and rear ends.

3. Final Answer:

   A dequeue allows insertion and deletion from both ends. -> Option A

4. Quick Check:

   Dequeue = Both ends operations [OK]

Hint: Dequeue = Double-ended queue, both ends allowed [OK]

Common Mistakes:

• Thinking dequeue is same as queue
• Assuming insertion only at rear
• Confusing dequeue with stack

2. Which of the following is the correct TypeScript method to add an element at the front of a dequeue implemented as an array?

easy

A. dequeue.pushFront(element);

B. dequeue.unshift(element);

C. dequeue.addFirst(element);

D. dequeue.insertFront(element);

Solution

1. Step 1: Recall array methods for front insertion

   In TypeScript/JavaScript, unshift() adds element at the front of an array.

2. Step 2: Check other options

   Methods like pushFront, addFirst, insertFront do not exist in standard arrays.

3. Final Answer:

   dequeue.unshift(element); -> Option B

4. Quick Check:

   Array front insert = unshift() [OK]

Hint: Use unshift() to add at front in arrays [OK]

Common Mistakes:

• Using push() instead of unshift()
• Assuming pushFront() exists
• Confusing with linked list methods

3. Consider this TypeScript code using an array as a dequeue:

let dequeue = [10, 20, 30];
dequeue.pop();
dequeue.unshift(5);
console.log(dequeue);

What is the output?

medium

A. [5, 10, 20]

B. [5, 10, 20, 30]

C. [10, 20, 30, 5]

D. [10, 20]

Solution

1. Step 1: Execute pop()

   pop() removes last element 30, so array becomes [10, 20].

2. Step 2: Execute unshift(5)

   unshift(5) adds 5 at front, array becomes [5, 10, 20].

3. Final Answer:

   [5, 10, 20] -> Option A

4. Quick Check:

   pop removes last, unshift adds front [OK]

Hint: pop removes last, unshift adds front [OK]

Common Mistakes:

• Assuming pop removes front
• Thinking unshift adds at end
• Confusing array order after operations

4. The following TypeScript code tries to remove an element from the front of a dequeue implemented as an array:

let dequeue = [1, 2, 3];
dequeue.removeFront();
console.log(dequeue);

What is the issue and how to fix it?

medium

A. removeFront() works only on linked lists; convert array to linked list.

B. removeFront() removes last element; use pop() instead.

C. removeFront() is not a valid method; use shift() instead.

D. No issue; code runs correctly.

Solution

1. Step 1: Identify invalid method

   Arrays in TypeScript do not have removeFront() method; this causes a runtime error.

2. Step 2: Use correct method for front removal

   shift() removes the first element from an array correctly.

3. Final Answer:

   removeFront() is not a valid method; use shift() instead. -> Option C

4. Quick Check:

   Front removal in arrays = shift() [OK]

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

Common Mistakes:

• Using non-existent removeFront() method
• Confusing pop() with front removal
• Thinking arrays have linked list methods

5. You have a dequeue implemented as an array: let dq = [1, 2, 3, 4];. You perform these operations:

dq.pop();
dq.unshift(0);
dq.push(5);
dq.shift();
console.log(dq);

What is the final state of the dequeue?

hard

A. [0, 1, 2, 3, 5]

B. [2, 3, 4, 5]

C. [1, 2, 3, 4, 5]

D. [1, 2, 3, 5]

Solution

1. Step 1: Execute pop()

   pop() removes last element 4, dq becomes [1, 2, 3].

2. Step 2: Execute unshift(0)

   unshift(0) adds 0 at front, dq becomes [0, 1, 2, 3].

3. Step 3: Execute push(5)

   push(5) adds 5 at end, dq becomes [0, 1, 2, 3, 5].

4. Step 4: Execute shift()

   shift() removes first element 0, dq becomes [1, 2, 3, 5].

5. Final Answer:

   [1, 2, 3, 5] -> Option D

6. Quick Check:

   pop removes end, unshift adds front, push adds end, shift removes front [OK]

Hint: Track each operation stepwise on array [OK]

Common Mistakes:

• Forgetting shift removes front element
• Mixing order of operations
• Assuming unshift adds at end