Double Ended Queue Deque in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the front index of the deque to -1.

DSA C

int front = [1];

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

A-1

B0

C1

DNULL

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing front to 0 causes confusion with valid index.

In deque implementation, front is initialized to -1 to indicate the deque is empty.

2fill in blank

medium

Complete the code to check if the deque is full when using a circular array of size MAX.

DSA C

if ((front == 0 && rear == MAX - 1) || (front == rear + 1)) {
    // Deque is full
    [1];
}

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

Aexit(1)

Breturn 0

Cprintf("Full")

Dreturn 1

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 0 instead of 1 for full condition.

Return 1 to indicate the deque is full in the isFull function.

3fill in blank

hard

Fix the error in the code that inserts an element at the front of the deque.

DSA C

void insertFront(int deque[], int *front, int *rear, int value) {
    if (isFull(*front, *rear)) {
        printf("Deque is full\n");
        return;
    }
    if (*front == -1) {
        *front = 0;
        *rear = 0;
    } else if (*front == 0) {
        *front = [1];
    } else {
        (*front)--;
    }
    deque[*front] = value;
}

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

A1

B0

CMAX - 1

D*front - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting front to 0 causes overwrite of first element.

When front is at 0, moving it to MAX - 1 wraps around the circular array.

4fill in blank

hard

Fill both blanks to correctly delete an element from the rear of the deque.

DSA C

void deleteRear(int deque[], int *front, int *rear) {
    if (*front == -1) {
        printf("Deque is empty\n");
        return;
    }
    if (*front == *rear) {
        *front = [1];
        *rear = [2];
    } else if (*rear == 0) {
        *rear = MAX - 1;
    } else {
        (*rear)--;
    }
}

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

A-1

B0

C1

DMAX - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting front or rear to 0 instead of -1 after last deletion.

When the last element is deleted, both front and rear are reset to -1 to indicate empty deque.

5fill in blank

hard

Fill all three blanks to correctly insert an element at the rear of the deque.

DSA C

void insertRear(int deque[], int *front, int *rear, int value) {
    if (isFull(*front, *rear)) {
        printf("Deque is full\n");
        return;
    }
    if (*front == -1) {
        *front = [1];
        *rear = [2];
    } else if (*rear == MAX - 1) {
        *rear = [3];
    } else {
        (*rear)++;
    }
    deque[*rear] = value;
}

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

A0

B-1

DMAX - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Incorrectly initializing front or rear to -1 when inserting first element.

When deque is empty, front and rear start at 0. If rear reaches MAX - 1, it wraps to 0.

Practice

1. What is a Double Ended Queue (Deque)?

easy

A. A queue where insertion happens only at the rear and deletion at the front

B. A data structure where insertion and deletion can happen at both ends

C. A stack where insertion and deletion happen only at one end

D. A list that allows random access to elements

Solution

1. Step 1: Understand the definition of Deque

   A Deque allows adding and removing elements from both front and rear ends.

2. Step 2: Compare with other data structures

   Unlike a queue or stack, Deque supports operations at both ends.

3. Final Answer:

   A data structure where insertion and deletion can happen at both ends -> Option B

4. Quick Check:

   Deque = Both ends insertion/deletion [OK]

Hint: Deque means double-ended queue, both ends allowed [OK]

Common Mistakes:

• Confusing deque with stack or queue
• Thinking insertion is only at one end
• Assuming random access like arrays

2. Which of the following is the correct syntax to initialize an empty deque in C using an array implementation?

easy

A. int deque[] = {}; int front = 0, rear = 0;

B. int deque[SIZE] = NULL; int front = 0, rear = 0;

C. int deque[SIZE]; int front = -1, rear = -1;

D. int deque[SIZE]; int front = 0, rear = -1;

Solution

1. Step 1: Understand initialization of deque with front and rear

   Front and rear are set to -1 to indicate empty deque.

2. Step 2: Check array declaration and initial values

   int deque[SIZE]; int front = -1, rear = -1; correctly declares array and sets front and rear to -1.

3. Final Answer:

   int deque[SIZE]; int front = -1, rear = -1; -> Option C

4. Quick Check:

   Empty deque front and rear = -1 [OK]

Hint: Empty deque front and rear start at -1 [OK]

Common Mistakes:

• Setting front or rear to 0 initially
• Using NULL for array initialization
• Leaving array size unspecified

3. Consider the following operations on an empty deque of size 5 implemented using an array:
insertRear(10); insertRear(20); insertFront(5); deleteRear(); insertFront(15);
What is the content of the deque from front to rear after these operations?

medium

A. 15 -> 5 -> 10 -> null

B. 5 -> 15 -> 10 -> null

C. 15 -> 5 -> null

D. 10 -> 5 -> 15 -> null

Solution

1. Step 1: Perform insertRear(10) and insertRear(20)

   Deque: 10 -> 20

2. Step 2: Perform insertFront(5)

   Deque: 5 -> 10 -> 20

3. Step 3: Perform deleteRear()

   Removes 20, Deque: 5 -> 10

4. Step 4: Perform insertFront(15)

   Deque: 15 -> 5 -> 10

5. Final Answer:

   15 -> 5 -> 10 -> null -> Option A

6. Quick Check:

   Operations result in 15,5,10 order [OK]

Hint: Track front and rear insertions stepwise [OK]

Common Mistakes:

• Forgetting deleteRear removes last element
• Mixing order of insertFront and insertRear
• Assuming insertFront adds at rear

4. Given the following code snippet for deque insertion at front, identify the error:

void insertFront(int deque[], int *front, int *rear, int value) {
  if (*front == 0) {
    printf("Deque is full at front\n");
    return;
  }
  (*front)--;
  deque[*front] = value;
}

medium

A. It incorrectly checks full condition only at front == 0

B. It decrements front before insertion causing invalid index

C. It does not check if deque is empty before insertion

D. It should increment front instead of decrement

Solution

1. Step 1: Analyze the full condition check

   Checking only if front == 0 is not enough to detect full deque.

2. Step 2: Understand circular deque logic

   Deque can be full even if front != 0, so this check is incomplete.

3. Final Answer:

   It incorrectly checks full condition only at front == 0 -> Option A

4. Quick Check:

   Full check must consider rear position too [OK]

Hint: Full deque check needs both front and rear positions [OK]

Common Mistakes:

• Assuming front == 0 means full always
• Not handling circular wrap-around
• Decrementing front without boundary check

5. You have a deque of size 4 implemented using a circular array. Initially empty, you perform:
insertRear(1); insertRear(2); insertFront(3); insertFront(4); deleteRear(); insertRear(5);
What is the final state of the deque from front to rear?

hard

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

B. 4 -> 3 -> 5 -> null

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

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

Solution

1. Step 1: InsertRear(1), InsertRear(2)

   Deque: 1 -> 2

2. Step 2: InsertFront(3), InsertFront(4)

   Deque: 4 -> 3 -> 1 -> 2 (deque full)

3. Step 3: DeleteRear()

   Removes 2, Deque: 4 -> 3 -> 1

4. Step 4: InsertRear(5)

   Deque: 4 -> 3 -> 1 -> 5 (full again)

5. Final Answer:

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

6. Quick Check:

   Circular deque final state matches 4 -> 3 -> 1 -> 5 -> null [OK]

Hint: Track circular wrap and full capacity carefully [OK]

Common Mistakes:

• Ignoring circular wrap-around
• Misordering front and rear elements
• Forgetting deleteRear removes last element