Queue Implementation Using Array in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add an element to the queue.

DSA Typescript

enqueue(item: number): void {
  if (this.rear === this.size - 1) {
    console.log('Queue is full');
  } else {
    this.rear = this.rear [1] 1;
    this.queue[this.rear] = item;
  }
}

Drag options to blanks, or click blank then click option'

A-

B/

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' to move rear forward.

Using '*' or '/' which are not valid for index increment.

To add an element, we increase the rear index by 1 using the '+' operator.

2fill in blank

medium

Complete the code to remove an element from the queue.

DSA Typescript

dequeue(): number | null {
  if (this.front > this.rear) {
    console.log('Queue is empty');
    return null;
  } else {
    const item = this.queue[this.front];
    this.front = this.front [1] 1;
    return item;
  }
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' which moves front backward incorrectly.

Using multiplication or division which are invalid here.

To remove an element, we move the front pointer forward by adding 1.

3fill in blank

hard

Fix the error in the method that checks if the queue is empty.

DSA Typescript

isEmpty(): boolean {
  return this.front [1] this.rear;
}

Drag options to blanks, or click blank then click option'

A==

B>

C<

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' which only checks equality, not emptiness.

Using '<' or '!=' which do not correctly check empty condition.

The queue is empty when front is greater than rear, so use '>' operator.

4fill in blank

hard

Fill both blanks to correctly initialize the queue in the constructor.

DSA Typescript

constructor(size: number) {
  this.size = size;
  this.queue = new Array(size).fill(0);
  this.front = [1];
  this.rear = [2];
}

Drag options to blanks, or click blank then click option'

A-1

B0

C1

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Setting rear to 0 which means queue is not empty initially.

Using null which is not a number index.

Front starts at 0 and rear starts at -1 indicating an empty queue.

5fill in blank

hard

Fill all three blanks to implement the peek method that returns the front element without removing it.

DSA Typescript

peek(): number | null {
  if (this.front [1] this.rear) {
    return this.queue[[2]];
  } else {
    return [3];
  }
}

Drag options to blanks, or click blank then click option'

A<=

Bfront

Cnull

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>=' which reverses the empty check.

Returning rear index instead of front element.

Returning 0 instead of null when empty.

Peek returns the front element if front <= rear, else returns null if empty.

Practice

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

easy

A. It stores elements in sorted order automatically

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

C. It allows random access to elements

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

Solution

1. Step 1: Understand queue behavior

   A queue adds elements at the rear 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 sorting is unrelated.

3. Final Answer:

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

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 way to add an element `x` to the rear of a queue implemented as an array named `queue` in TypeScript?

easy

A. queue.unshift(x);

B. queue.push(x);

C. queue.shift(x);

D. queue.pop(x);

Solution

1. Step 1: Identify array methods for queue operations

   To add at the rear of the queue, we use the array method that appends elements at the end, which is push().

2. Step 2: Check each option

   push(x) adds x at the end; pop() removes from end; shift() removes from front; unshift() adds at front.

3. Final Answer:

   queue.push(x); -> Option B

4. Quick Check:

   Enqueue = push() [OK]

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

Common Mistakes:

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

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

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

medium

A. [20, 30]

B. [10, 20, 30]

C. [30, 20]

D. [10, 30]

Solution

1. Step 1: Trace queue operations step-by-step

   Initially queue = []. After push(10), queue = [10]. After push(20), queue = [10, 20]. shift() removes first element 10, queue = [20]. Then push(30), queue = [20, 30].

2. Step 2: Determine final queue state

   After all operations, queue contains [20, 30].

3. Final Answer:

   [20, 30] -> Option A

4. Quick Check:

   After shift(), first element removed, queue = [20, 30] [OK]

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

Common Mistakes:

• Forgetting shift() removes first element
• Assuming push() adds at front
• Confusing order of elements after operations

4. Identify the error in the following TypeScript code for queue implementation using an array:

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

medium

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

B. queue should be declared as a linked list

C. Using pop() removes from rear, not front

D. No error, code works correctly

Solution

1. Step 1: Understand queue removal operation

   Queue removes elements from the front (FIFO). Using pop() removes from the rear (last element), which breaks FIFO.

2. Step 2: Check code behavior

   pop() removes last element (2), but queue should remove first element (1) using shift().

3. Final Answer:

   Using pop() removes from rear, not front -> Option C

4. Quick Check:

   Dequeue = shift(), not pop() [OK]

Hint: Use shift() to remove front element, not pop() [OK]

Common Mistakes:

• Using pop() instead of shift() for dequeue
• Thinking push() adds at front
• Confusing array methods for queue operations

5. You want to implement a queue using a fixed-size array of length 3 in TypeScript. After enqueueing 3 elements, you dequeue one element and then enqueue another. What problem will you face if you do not use a circular queue approach?

hard

A. You cannot enqueue the new element because the rear index reached the array end

B. The queue will automatically resize to fit new elements

C. Dequeue operation will remove the wrong element

D. The queue will lose all previous elements

Solution

1. Step 1: Understand fixed-size array queue behavior

   With a fixed-size array, rear index moves forward on enqueue. After 3 enqueues, rear is at end.

2. Step 2: Analyze enqueue after dequeue without circular logic

   Dequeue moves front forward but rear stays at end. Without circular wrap, rear cannot move back to start, so enqueue fails.

3. Final Answer:

   You cannot enqueue the new element because the rear index reached the array end -> Option A

4. Quick Check:

   Fixed array + no circular = enqueue blocked at end [OK]

Hint: Fixed array needs circular logic to reuse space [OK]

Common Mistakes:

• Assuming array resizes automatically
• Thinking dequeue affects rear index
• Ignoring circular queue necessity