Dequeue Using Linked List in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with given data.

DSA C

struct Node* newNode(int data) {
    struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = [1];
    temp->prev = NULL;
    temp->next = NULL;
    return temp;
}

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

Adata

BNULL

Ctemp

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning NULL or 0 instead of the input data.

Using the pointer variable instead of the data value.

The new node's data field should be set to the input parameter data.

2fill in blank

medium

Complete the code to insert a node at the front of the dequeue.

DSA C

void insertFront(struct Dequeue* dq, int data) {
    struct Node* temp = newNode(data);
    if (dq->front == NULL) {
        dq->front = dq->rear = temp;
    } else {
        temp->next = dq->front;
        dq->front->prev = [1];
        dq->front = temp;
    }
}

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

Adq->rear

BNULL

Ctemp

Ddq->front

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev pointer to NULL or rear instead of the new node.

Not updating the prev pointer at all.

The previous pointer of the old front node should point to the new node temp.

3fill in blank

hard

Fix the error in the code to delete a node from the rear of the dequeue.

DSA C

void deleteRear(struct Dequeue* dq) {
    if (dq->rear == NULL) return;
    struct Node* temp = dq->rear;
    dq->rear = dq->rear->prev;
    if (dq->rear != NULL) {
        dq->rear->next = [1];
    } else {
        dq->front = NULL;
    }
    free(temp);
}

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

Adq->rear

Btemp

Cdq->front

DNULL

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next pointer to temp or rear instead of NULL.

Not updating the next pointer after deletion.

After removing the rear node, the new rear's next pointer should be set to NULL to mark the end of the list.

4fill in blank

hard

Fill both blanks to insert a node at the rear of the dequeue correctly.

DSA C

void insertRear(struct Dequeue* dq, int data) {
    struct Node* temp = newNode(data);
    if (dq->rear == NULL) {
        dq->front = dq->rear = temp;
    } else {
        dq->rear->next = [1];
        temp->prev = [2];
        dq->rear = temp;
    }
}

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

Atemp

Bdq->front

Cdq->rear

DNULL

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up prev and next pointers.

Setting pointers to NULL incorrectly.

The current rear's next pointer should point to the new node temp, and the new node's prev pointer should point back to the current rear node.

5fill in blank

hard

Fill all three blanks to delete a node from the front of the dequeue correctly.

DSA C

void deleteFront(struct Dequeue* dq) {
    if (dq->front == NULL) return;
    struct Node* temp = dq->front;
    dq->front = dq->front->[1];
    if (dq->front != NULL) {
        dq->front->[2] = [3];
    } else {
        dq->rear = NULL;
    }
    free(temp);
}

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

Anext

Bprev

CNULL

Dfront

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of next to move front pointer.

Not setting prev pointer of new front to NULL.

Setting pointers to wrong nodes.

After deleting the front node, update dq->front to its next node, then set the new front's prev pointer to NULL to mark the start of the list.

Practice

1. What is the main advantage of using a linked list to implement a dequeue compared to an array?

easy

A. Dynamic size allows easy insertion and deletion at both ends

B. Faster access to elements by index

C. Uses less memory than arrays

D. Simpler to implement than arrays

Solution

1. Step 1: Understand linked list flexibility

   A linked list can grow or shrink dynamically without needing a fixed size.

2. Step 2: Compare with array limitations

   Arrays have fixed size and costly resizing; linked lists allow easy insertion/deletion at both ends.

3. Final Answer:

   Dynamic size allows easy insertion and deletion at both ends -> Option A

4. Quick Check:

   Linked list dynamic size = Advantage [OK]

Hint: Linked lists grow/shrink easily at ends [OK]

Common Mistakes:

• Confusing faster index access with linked list
• Thinking linked lists always use less memory
• Assuming arrays are simpler to implement

2. Which of the following is the correct way to declare a node structure for a dequeue using a linked list in C?

easy

A. struct Node { int data; struct Node* next; };

B. struct Node { int data; struct Node next; struct Node prev; };

C. struct Node { int data; int next; int prev; };

D. struct Node { int data; struct Node* next; struct Node* prev; };

Solution

1. Step 1: Identify node fields for dequeue

   A dequeue node needs data and pointers to next and previous nodes for double linking.

2. Step 2: Check pointer types

   Correct syntax uses pointers (struct Node*) for next and prev, not int or struct Node directly.

3. Final Answer:

   struct Node { int data; struct Node* next; struct Node* prev; }; -> Option D

4. Quick Check:

   Double linked node = data + next ptr + prev ptr [OK]

Hint: Double linked nodes need next and prev pointers [OK]

Common Mistakes:

• Using int instead of pointer for next/prev
• Missing prev pointer for dequeue
• Declaring next/prev as struct Node instead of pointer

3. Consider the following operations on an empty dequeue implemented using a linked list:
insertFront(10); insertRear(20); insertFront(5); deleteRear();
What will be the state of the dequeue from front to rear after these operations?

medium

A. 5 -> 10 -> null

B. 10 -> 5 -> null

C. 20 -> 10 -> null

D. 5 -> 20 -> null

Solution

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

   Dequeue: 10 (front) -> 20 (rear)

2. Step 2: Perform insertFront(5) and deleteRear()

   After insertFront(5): 5 -> 10 -> 20
   After deleteRear(): removes 20, so 5 -> 10

3. Final Answer:

   5 -> 10 -> null -> Option A

4. Quick Check:

   Front insert adds at front, rear delete removes last [OK]

Hint: Track front and rear changes stepwise [OK]

Common Mistakes:

• Confusing insertFront and insertRear order
• Forgetting to delete rear element
• Mixing up front and rear positions

4. The following C code snippet for deleting from the front of a dequeue has an error. What is the error?

void deleteFront() {
  if (front == NULL) {
    printf("Dequeue is empty\n");
    return;
  }
  struct Node* temp = front;
  front = front->next;
  if (front == NULL) {
    rear = NULL;
  }
  free(temp);
}

medium

A. Uses free() incorrectly

B. Does not check if dequeue is full

C. Does not update the prev pointer of new front node

D. Does not update rear pointer when dequeue becomes empty

Solution

1. Step 1: Analyze pointer updates after deletion

   After moving front to front->next, the new front's prev pointer still points to old node.

2. Step 2: Identify missing update

   Must set front->prev = NULL to maintain correct double link.

3. Final Answer:

   Does not update the prev pointer of new front node -> Option C

4. Quick Check:

   Update prev pointer after front deletion [OK]

Hint: Always reset prev of new front to NULL [OK]

Common Mistakes:

• Ignoring prev pointer update
• Checking dequeue full in delete function
• Not updating rear when empty (not shown here)

5. You want to implement a function to reverse a dequeue implemented using a doubly linked list. Which approach correctly reverses the dequeue?

hard

A. Only swap front and rear pointers without changing node links

B. Swap next and prev pointers of each node, then swap front and rear pointers

C. Delete all nodes and re-insert them from rear to front

D. Traverse from front to rear and copy data into a new list in reverse order

Solution

1. Step 1: Understand reversing a doubly linked list

   Reversing means each node's next and prev pointers must be swapped to reverse direction.

2. Step 2: Swap front and rear pointers

   After swapping pointers in nodes, front and rear pointers must also be swapped to reflect new ends.

3. Final Answer:

   Swap next and prev pointers of each node, then swap front and rear pointers -> Option B

4. Quick Check:

   Swap links + swap ends = reverse dequeue [OK]

Hint: Swap next/prev in nodes, then swap front/rear [OK]

Common Mistakes:

• Only swapping front and rear pointers
• Rebuilding list instead of reversing links
• Copying data instead of changing pointers