Dequeue Operation in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to remove an element from the front of the dequeue.

DSA C

int dequeueFront() {
    if (front == -1) {
        return -1; // Dequeue is empty
    }
    int data = arr[front];
    if (front == rear) {
        front = rear = -1;
    } else {
        front = [1];
    }
    return data;
}

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

Arear - 1

Bfront - 1

Crear + 1

Dfront + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Moving the front pointer backward instead of forward.

Changing the rear pointer instead of the front.

When removing from the front, we move the front pointer forward by 1.

2fill in blank

medium

Complete the code to remove an element from the rear of the dequeue.

DSA C

int dequeueRear() {
    if (rear == -1) {
        return -1; // Dequeue is empty
    }
    int data = arr[rear];
    if (front == rear) {
        front = rear = -1;
    } else {
        rear = [1];
    }
    return data;
}

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

Arear - 1

Bfront + 1

Cfront - 1

Drear + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Moving the rear pointer forward instead of backward.

Changing the front pointer instead of the rear.

When removing from the rear, we move the rear pointer backward by 1.

3fill in blank

hard

Fix the error in the condition that checks if the dequeue is empty.

DSA C

int isEmpty() {
    if ([1]) {
        return 1;
    }
    return 0;
}

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

Afront == rear

Bfront == 0 && rear == 0

Cfront == -1 && rear == -1

Dfront > rear

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if front and rear are zero instead of -1.

Using front == rear which can be true when one element is present.

The dequeue is empty when both front and rear are -1.

4fill in blank

hard

Fill both blanks to correctly update the front pointer in a circular dequeue after removing from front.

DSA C

void dequeueFrontCircular() {
    if (front == -1) {
        return; // Empty dequeue
    }
    if (front == rear) {
        front = rear = -1;
    } else {
        front = (front [1] 1) [2] size;
    }
}

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

A+

B-

C%

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition.

Using division instead of modulo for wrapping.

In circular dequeue, front moves forward by 1 and wraps around using modulo operator.

5fill in blank

hard

Fill all three blanks to correctly update the rear pointer in a circular dequeue after removing from rear.

DSA C

void dequeueRearCircular() {
    if (rear == -1) {
        return; // Empty dequeue
    }
    if (front == rear) {
        front = rear = -1;
    } else {
        rear = (rear [1] 1 + [2]) [3] size;
    }
}

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

A+

B-

Csize

D%

Attempts:

3 left

💡 Hint

Common Mistakes

Not adding size before modulo causing negative index.

Using addition instead of subtraction.

To move rear backward in circular dequeue, subtract 1, add size to avoid negative, then modulo size.

Practice

1. What is a dequeue in data structures?

easy

A. A double-ended queue allowing insertion and deletion at both ends

B. A queue where elements are inserted only at the front

C. A stack that allows only last-in-first-out operations

D. A linked list with only one pointer per node

Solution

1. Step 1: Understand the definition of dequeue

   A dequeue is a data structure where elements can be added or removed from both front and rear ends.

2. Step 2: Compare options with definition

   A double-ended queue allowing insertion and deletion at both ends correctly describes a dequeue. Options B, C, and D describe other data structures.

3. Final Answer:

   A double-ended queue allowing insertion and deletion at both ends -> Option A

4. Quick Check:

   Dequeue = double-ended queue [OK]

Hint: Dequeue means double-ended queue, both ends usable [OK]

Common Mistakes:

• Confusing dequeue with stack or simple queue
• Thinking insertion is only at one end
• Mixing dequeue with linked list structure

2. Which of the following is the correct syntax to insert an element 10 at the front of a dequeue named dq in C?

easy

A. dq.insertFront(10);

B. insertFront(dq, 10);

C. dq->insertFront(10);

D. insertFront(10, dq);

Solution

1. Step 1: Identify typical C function call syntax

   In C, functions are called with function_name(arguments). Here, insertFront is a function taking dequeue and value.

2. Step 2: Match options with C syntax

   insertFront(dq, 10); matches C style: insertFront(dq, 10);. Options B and C use object syntax (C++ style). insertFront(10, dq); reverses argument order.

3. Final Answer:

   insertFront(dq, 10); -> Option B

4. Quick Check:

   C function call = insertFront(dq, 10) [OK]

Hint: C uses function_name(dequeue, value) syntax [OK]

Common Mistakes:

• Using object method syntax in C
• Swapping argument order
• Using arrow operator without pointer

3. Consider the following C code for dequeue operations:

initialize dequeue dq
insertRear(dq, 5);
insertFront(dq, 3);
insertRear(dq, 7);
deleteFront(dq);
insertFront(dq, 2);
deleteRear(dq);

What is the final state of the dequeue (front to rear)?

medium

A. 2 -> 3 -> null

B. 3 -> 5 -> 7 -> null

C. 2 -> 5 -> null

D. 5 -> 7 -> null

Solution

1. Step 1: Trace each operation step-by-step

   Start empty: [] insertRear 5: [5] insertFront 3: [3,5] insertRear 7: [3,5,7] deleteFront: remove 3 -> [5,7] insertFront 2: [2,5,7] deleteRear: remove 7 -> [2,5]

2. Step 2: Write final dequeue state front to rear

   Final state is 2 at front, then 5, then null.

3. Final Answer:

   2 -> 5 -> null -> Option C

4. Quick Check:

   Trace ops carefully = 2 -> 5 [OK]

Hint: Track each insert/delete step in order [OK]

Common Mistakes:

• Forgetting which end deleteFront/deleteRear affects
• Mixing order of insertFront and insertRear
• Skipping an operation

4. The following code snippet for dequeue operations has a bug. What is the error?

initialize dequeue dq
insertFront(dq, 10);
deleteRear(dq);
deleteRear(dq);

medium

A. Deleting from rear when dequeue is empty causes underflow

B. insertFront syntax is incorrect

C. Cannot deleteRear twice in a row

D. Dequeue must be initialized with size

Solution

1. Step 1: Analyze operations and dequeue state

   Start empty: [] insertFront 10: [10] deleteRear: removes 10 -> [] deleteRear: tries to remove from empty dequeue

2. Step 2: Identify error from empty dequeue deletion

   Deleting from empty dequeue causes underflow error. This is the bug.

3. Final Answer:

   Deleting from rear when dequeue is empty causes underflow -> Option A

4. Quick Check:

   Deleting empty dequeue = underflow error [OK]

Hint: Check if dequeue is empty before delete [OK]

Common Mistakes:

• Ignoring empty dequeue before delete
• Assuming multiple deletes always safe
• Confusing insert syntax with error

5. You have a dequeue initially empty. You perform these operations:

insertRear(dq, 1);
insertRear(dq, 2);
insertFront(dq, 3);
deleteRear(dq);
insertFront(dq, 4);
deleteFront(dq);
insertRear(dq, 5);

What is the final state of the dequeue from front to rear?

hard

A. 4 -> 3 -> 1 -> null

B. 1 -> 5 -> null

C. 4 -> 1 -> 5 -> null

D. 3 -> 1 -> 5 -> null

Solution

1. Step 1: Execute each operation stepwise

   Start: [] insertRear 1: [1] insertRear 2: [1,2] insertFront 3: [3,1,2] deleteRear: remove 2 -> [3,1] insertFront 4: [4,3,1] deleteFront: remove 4 -> [3,1] insertRear 5: [3,1,5]

2. Step 2: Write final dequeue state front to rear

   Final state is 3 at front, then 1, then 5, then null.

3. Final Answer:

   3 -> 1 -> 5 -> null -> Option D

4. Quick Check:

   Trace carefully = 3 -> 1 -> 5 [OK]

Hint: Write state after each operation [OK]

Common Mistakes:

• Deleting wrong end element
• Mixing insertFront and insertRear order
• Skipping delete operations