Queue Implementation Using Linked List in DSA C

Mental Model

A queue is a line where elements wait their turn. Using a linked list means each element points to the next, so we can add at the end and remove from the front easily.

Analogy: Imagine a line of people waiting to buy tickets. The first person in line is served and leaves, and new people join at the end of the line. Each person holds the hand of the next person, so the line stays connected.

front -> [node1] -> [node2] -> [node3] -> null
rear ↑

Dry Run Walkthrough

Input: Start with empty queue, enqueue 10, enqueue 20, dequeue once

Goal: Show how elements are added at the rear and removed from the front in a linked list queue

Step 1: enqueue 10: create node with 10, front and rear point to it

front -> [10] -> null
rear ↑

Why: First element sets both front and rear pointers

Step 2: enqueue 20: create node with 20, link rear's next to new node, move rear to new node

front -> [10] -> [20] -> null
rear ↑

Why: Add new element at the end and update rear pointer

Step 3: dequeue: remove node at front (10), move front to next node (20)

front -> [20] -> null
rear ↑

Why: Remove from front to maintain queue order

Result:

front -> [20] -> null
rear ↑

Annotated Code

DSA C

#include <stdio.h>
#include <stdlib.h>

// Node structure for linked list
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// Queue structure with front and rear pointers
typedef struct Queue {
    Node* front;
    Node* rear;
} Queue;

// Create an empty queue
Queue* createQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = NULL;
    q->rear = NULL;
    return q;
}

// Enqueue operation: add element at rear
void enqueue(Queue* q, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;

    if (q->rear == NULL) {
        // Queue empty, front and rear are same
        q->front = newNode;
        q->rear = newNode;
        return;
    }

    // Link new node at the end and update rear
    q->rear->next = newNode;
    q->rear = newNode;
}

// Dequeue operation: remove element from front
int dequeue(Queue* q) {
    if (q->front == NULL) {
        // Queue empty
        return -1; // Indicate empty queue
    }

    Node* temp = q->front;
    int value = temp->data;
    q->front = q->front->next;

    // If front becomes NULL, then queue is empty, update rear
    if (q->front == NULL) {
        q->rear = NULL;
    }

    free(temp);
    return value;
}

// Print queue elements from front to rear
void printQueue(Queue* q) {
    Node* temp = q->front;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("null\n");
}

int main() {
    Queue* q = createQueue();

    enqueue(q, 10);
    enqueue(q, 20);
    printQueue(q); // Expected: 10 -> 20 -> null

    int val = dequeue(q);
    printf("Dequeued: %d\n", val); // Expected: Dequeued: 10

    printQueue(q); // Expected: 20 -> null

    return 0;
}

if (q->rear == NULL) {

Check if queue is empty to set front and rear to new node

q->rear->next = newNode;

Link new node at the end of queue

q->rear = newNode;

Update rear pointer to new node

if (q->front == NULL) {

Check if queue is empty before dequeue

q->front = q->front->next;

Move front pointer to next node to remove front element

if (q->front == NULL) { q->rear = NULL; }

If queue becomes empty after dequeue, update rear to NULL

Output

10 -> 20 -> null

Dequeued: 10

20 -> null

Complexity Analysis

Time: O(1) for both enqueue and dequeue because we add or remove nodes directly at rear or front without traversal

Space: O(n) because each element is stored in a separate node linked together

vs Alternative: Compared to array-based queue, linked list avoids shifting elements on dequeue, making operations faster and memory usage dynamic

Edge Cases

Dequeue from empty queue

Returns -1 indicating queue is empty, no crash

DSA C

if (q->front == NULL) { return -1; }

Enqueue first element into empty queue

Both front and rear pointers set to new node

DSA C

if (q->rear == NULL) { q->front = newNode; q->rear = newNode; return; }

Dequeue last element making queue empty

Front becomes NULL and rear is updated to NULL

DSA C

if (q->front == NULL) { q->rear = NULL; }

When to Use This Pattern

When you need a first-in-first-out structure with dynamic size and efficient add/remove at ends, use a linked list queue to avoid costly shifts.

Common Mistakes

Mistake: Not updating rear pointer to NULL when queue becomes empty after dequeue
Fix: Set rear to NULL when front becomes NULL after removing last element

Mistake: Linking new node incorrectly causing broken chain
Fix: Always set rear->next to new node before updating rear pointer

Summary

Implements a queue using a linked list with front and rear pointers.

Use when you want a queue that grows dynamically without shifting elements.

Remember to update both front and rear pointers correctly when queue becomes empty or when adding the first element.

Practice

1. What is the main advantage of implementing a queue using a linked list instead of an array?

easy

A. Uses less memory than arrays always

B. Faster access to elements by index

C. Simpler code with fewer pointers

D. Dynamic size allows efficient memory use without fixed limits

Solution

1. Step 1: Understand queue size constraints in arrays

   Arrays have fixed size, so queues implemented with arrays have a maximum capacity.

2. Step 2: Analyze linked list flexibility

   Linked lists can grow or shrink dynamically, so queues using linked lists can handle any number of elements limited only by memory.

3. Final Answer:

   Dynamic size allows efficient memory use without fixed limits -> Option D

4. Quick Check:

   Linked list queues grow dynamically = A [OK]

Hint: Linked list queues grow dynamically, arrays don't [OK]

Common Mistakes:

• Thinking arrays always use less memory
• Confusing access speed with size flexibility
• Assuming linked lists have simpler code

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

easy

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

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

C. typedef struct Node { int data; struct Node* next; } Node;

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

Solution

1. Step 1: Check pointer usage in struct

   The next pointer must be a pointer to struct Node, so 'struct Node* next;' is correct.

2. Step 2: Validate typedef syntax

   Using typedef with struct Node allows using 'Node' as type directly, which is correct in typedef struct Node { int data; struct Node* next; } Node;.

3. Final Answer:

   typedef struct Node { int data; struct Node* next; } Node; -> Option C

4. Quick Check:

   Pointer to struct Node with typedef = A [OK]

Hint: Use 'struct Node* next;' for pointer inside struct [OK]

Common Mistakes:

• Using 'int next;' instead of pointer
• Omitting 'struct' keyword before Node*
• Declaring next as struct Node instead of pointer

3. Consider the following C code snippet implementing enqueue operation for a queue using linked list:

void enqueue(Node** front, Node** rear, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    if (*rear == NULL) {
        *front = *rear = newNode;
    } else {
        (*rear)->next = newNode;
        *rear = newNode;
    }
}

What will be the state of the queue after these operations? enqueue(&front, &rear, 10); enqueue(&front, &rear, 20); enqueue(&front, &rear, 30);

medium

A. 10 -> 20 -> 30 -> NULL

B. 30 -> 20 -> 10 -> NULL

C. 10 -> 30 -> 20 -> NULL

D. 20 -> 10 -> 30 -> NULL

Solution

1. Step 1: Trace first enqueue call

   Queue is empty, so front and rear point to new node with data 10.

2. Step 2: Trace second and third enqueue calls

   New nodes with 20 and 30 are added at rear, linked in order: 10 -> 20 -> 30 -> NULL.

3. Final Answer:

   10 -> 20 -> 30 -> NULL -> Option A

4. Quick Check:

   Enqueue adds at rear, order preserved = C [OK]

Hint: Enqueue adds at rear, so order is insertion order [OK]

Common Mistakes:

• Confusing enqueue with push (stack behavior)
• Reversing order of nodes
• Not updating rear pointer correctly

4. The following dequeue function for a queue using linked list has a bug. Identify the bug:

int dequeue(Node** front, Node** rear) {
    if (*front == NULL) {
        printf("Queue is empty\n");
        return -1;
    }
    Node* temp = *front;
    int value = temp->data;
    *front = (*front)->next;
    free(temp);
    return value;
}

medium

A. Does not free memory of dequeued node

B. Does not update rear when queue becomes empty

C. Returns wrong value after dequeue

D. Does not check if front is NULL before dequeue

Solution

1. Step 1: Analyze dequeue steps

   Function removes front node and updates front pointer correctly.

2. Step 2: Check rear pointer update

   If after dequeue front becomes NULL (queue empty), rear should also be set to NULL but this is missing.

3. Final Answer:

   Does not update rear when queue becomes empty -> Option B

4. Quick Check:

   Rear must be NULL if queue empty = B [OK]

Hint: Set rear to NULL when front becomes NULL after dequeue [OK]

Common Mistakes:

• Forgetting to update rear on empty queue
• Not freeing dequeued node memory
• Returning wrong data value

5. You want to implement a function reverseQueue that reverses the elements of a queue implemented using a linked list. Which approach is the most efficient and correct?

hard

A. Use a stack to push all elements, then enqueue them back to queue

B. Traverse the linked list and swap data of front and rear nodes repeatedly

C. Dequeue all elements and enqueue them back in the same order

D. Create a new linked list and copy elements in reverse order without modifying original

Solution

1. Step 1: Understand reversing queue with linked list

   Reversing requires changing order of elements, which is not straightforward by swapping nodes in singly linked list.

2. Step 2: Evaluate stack approach

   Using a stack to push all elements then enqueue back reverses order efficiently and correctly.

3. Step 3: Check other options

   Swapping data repeatedly is complex and error-prone; copying to new list wastes memory; re-enqueueing same order does nothing.

4. Final Answer:

   Use a stack to push all elements, then enqueue them back to queue -> Option A

5. Quick Check:

   Stack reverses order efficiently = D [OK]

Hint: Use stack to reverse queue elements easily [OK]

Common Mistakes:

• Trying to swap nodes in singly linked list
• Re-enqueueing without changing order
• Copying to new list wastes memory