Dequeue Operation in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Dequeue Front Operation

What is the output of the following C code that performs a dequeue front operation on a dequeue?

DSA C

#include <stdio.h>
#include <stdlib.h>
#define MAX 5

int dequeue[MAX];
int front = -1, rear = -1;

void enqueueRear(int x) {
    if ((front == 0 && rear == MAX - 1) || (rear == (front - 1 + MAX) % MAX)) {
        printf("Queue is Full\n");
        return;
    } else if (front == -1) {
        front = rear = 0;
        dequeue[rear] = x;
    } else if (rear == MAX - 1 && front != 0) {
        rear = 0;
        dequeue[rear] = x;
    } else {
        rear++;
        dequeue[rear] = x;
    }
}

int dequeueFront() {
    if (front == -1) {
        printf("Queue is Empty\n");
        return -1;
    }
    int data = dequeue[front];
    if (front == rear) {
        front = rear = -1;
    } else if (front == MAX - 1) {
        front = 0;
    } else {
        front++;
    }
    return data;
}

int main() {
    enqueueRear(10);
    enqueueRear(20);
    enqueueRear(30);
    int val = dequeueFront();
    printf("Dequeued: %d\n", val);
    printf("Front element now: %d\n", dequeue[front]);
    return 0;
}

A

Dequeued: 10
Front element now: 20

B

Dequeued: 20
Front element now: 30

C

Dequeued: 30
Front element now: 10

D

Queue is Empty
Dequeued: -1
Front element now: 10

💡 Hint

Remember that dequeueFront removes the element at the front and updates the front pointer.

The dequeueFront function removes the element at the front index, which is 10, then moves front to the next element, which is 20. So the dequeued value is 10 and the new front element is 20.

❓ Predict Output

intermediate

Output after Dequeue Rear Operation

What is the output of this C code after performing a dequeue rear operation on a dequeue?

DSA C

#include <stdio.h>
#include <stdlib.h>
#define MAX 4

int dequeue[MAX];
int front = 0, rear = 2;

void enqueueRear(int x) {
    if ((front == 0 && rear == MAX - 1) || (rear == (front - 1 + MAX) % MAX)) {
        printf("Queue is Full\n");
        return;
    }
    if (rear == MAX - 1 && front != 0) {
        rear = 0;
    } else {
        rear++;
    }
    dequeue[rear] = x;
}

int dequeueRear() {
    if (front == -1) {
        printf("Queue is Empty\n");
        return -1;
    }
    int data = dequeue[rear];
    if (front == rear) {
        front = rear = -1;
    } else if (rear == 0) {
        rear = MAX - 1;
    } else {
        rear--;
    }
    return data;
}

int main() {
    dequeue[0] = 5;
    dequeue[1] = 10;
    dequeue[2] = 15;
    int val = dequeueRear();
    printf("Dequeued from rear: %d\n", val);
    printf("Rear element now: %d\n", dequeue[rear]);
    return 0;
}

A

Dequeued from rear: 5
Rear element now: 15

B

Dequeued from rear: 10
Rear element now: 5

C

Dequeued from rear: 15
Rear element now: 10

D

Queue is Empty
Dequeued from rear: -1
Rear element now: 15

💡 Hint

Dequeue rear removes the element at the rear index and updates rear pointer accordingly.

The dequeueRear function removes the element at rear index 2, which is 15, then moves rear pointer back to 1, so the new rear element is 10.

🔧 Debug

advanced

Identify the Bug in Dequeue Front Function

What error will occur when running this dequeue front function code snippet?

DSA C

int dequeueFront() {
    if (front == -1) {
        printf("Queue is Empty\n");
        return -1;
    }
    int data = dequeue[front];
    if (front == rear) {
        front = rear = -1;
    } else if (front == MAX - 1) {
        front = 0;
    } else {
        front++;
    }
    return data;
}

A No error, works correctly

B Compilation error due to missing return statement

C Infinite loop due to front never updating

D Runs into out-of-bounds array access when front == MAX

💡 Hint

Check the condition that resets front to 0 after reaching the end.

The condition should check if front == MAX - 1, not front == MAX. When front == MAX, it accesses dequeue[MAX], which is out of bounds causing undefined behavior.

🧠 Conceptual

advanced

Understanding Circular Dequeue Full Condition

Which condition correctly checks if a circular dequeue is full?

A (front == 0 && rear == MAX - 1) || (rear == (front - 1 + MAX) % MAX)

B front == -1 && rear == -1

C front == rear

D rear == front + 1

💡 Hint

In a circular dequeue, full means rear is just before front in a circular manner.

Option A correctly checks if rear is just before front either at the end or wrapped around, indicating the dequeue is full.

🚀 Application

expert

Resulting Dequeue State After Operations

Given an empty dequeue of size 5, after performing these operations in order: 1. enqueueRear(1) 2. enqueueRear(2) 3. enqueueFront(3) 4. dequeueRear() 5. enqueueFront(4) What is the state of the dequeue from front to rear?

A 4 -> 3 -> 1 -> 2 -> null

B 4 -> 3 -> 1 -> null

C 3 -> 1 -> 4 -> null

D 3 -> 4 -> 1 -> null

💡 Hint

Track front and rear pointers carefully after each operation.

After enqueueRear(1) and enqueueRear(2), dequeue is 1 -> 2. enqueueFront(3) adds 3 at front: 3 -> 1 -> 2. dequeueRear() removes 2: 3 -> 1. enqueueFront(4) adds 4 at front: 4 -> 3 -> 1. So final state is 4 -> 3 -> 1 -> null.

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