Queue Implementation Using Linked List in DSA C - Build from Scratch

Queue Implementation Using Linked List

📖 Scenario: Imagine a line at a ticket counter where people join at the end and get served from the front. This is how a queue works. We will build a queue using a linked list in C to manage this line efficiently.

🎯 Goal: Create a queue using a linked list in C. You will add elements to the end and remove elements from the front, then print the queue to see the order of people waiting.

📋 What You'll Learn

Define a Node struct with an integer data and a pointer to the next node called next.

Create a Queue struct with pointers front and rear to track the start and end of the queue.

Write a function enqueue to add a new node with given data at the rear of the queue.

Write a function dequeue to remove the node from the front of the queue.

Write a function printQueue to display all elements from front to rear.

Demonstrate the queue by enqueuing and dequeuing elements and printing the queue.

💡 Why This Matters

🌍 Real World

Queues are used in real life for managing lines, like customers waiting for service or tasks waiting to be processed.

💼 Career

Understanding queue implementation helps in software development roles where managing ordered data efficiently is important, such as in operating systems, network programming, and event handling.

1

Define Node and Queue Structures

Define a struct Node with an int data and a struct Node* next. Then define a struct Queue with two pointers: front and rear, both of type struct Node*.

DSA C

# Define struct Node and struct Queue
// Your code here

Hint

Think of Node as a box holding a number and a pointer to the next box. The Queue keeps track of the first and last boxes.

2

Initialize Queue and Write Enqueue Function

Create a function initQueue that returns a pointer to a new Queue with front and rear set to NULL. Then write a function enqueue that takes a pointer to Queue and an int data, creates a new Node with this data, and adds it to the rear of the queue.

DSA C

#include 
#include 

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

struct Queue {
    struct Node* front;
    struct Node* rear;
};

// Write initQueue and enqueue functions below
// Your code here

Hint

When the queue is empty, both front and rear point to the new node. Otherwise, add the new node after rear and update rear.

3

Write Dequeue and Print Functions

Write a function dequeue that removes the node from the front of the queue and frees its memory. If the queue becomes empty, set rear to NULL. Also write a function printQueue that prints all elements from front to rear separated by arrows -> and ends with NULL.

DSA C

#include 
#include 

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

struct Queue {
    struct Node* front;
    struct Node* rear;
};

struct Queue* initQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = NULL;
    q->rear = NULL;
    return q;
}

void enqueue(struct Queue* q, int data) {
    struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = data;
    temp->next = NULL;
    if (q->rear == NULL) {
        q->front = temp;
        q->rear = temp;
        return;
    }
    q->rear->next = temp;
    q->rear = temp;
}

// Write dequeue and printQueue functions below
// Your code here

Hint

Remove the front node and update pointers. For printing, move from front to rear printing each data followed by an arrow.

4

Test Queue Operations and Print Final Queue

In main, create a queue using initQueue(). Enqueue the integers 10, 20, and 30 in that order. Then dequeue one element. Finally, call printQueue to display the current queue.

DSA C

#include 
#include 

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

struct Queue {
    struct Node* front;
    struct Node* rear;
};

struct Queue* initQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = NULL;
    q->rear = NULL;
    return q;
}

void enqueue(struct Queue* q, int data) {
    struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = data;
    temp->next = NULL;
    if (q->rear == NULL) {
        q->front = temp;
        q->rear = temp;
        return;
    }
    q->rear->next = temp;
    q->rear = temp;
}

void dequeue(struct Queue* q) {
    if (q->front == NULL) {
        return;
    }
    struct Node* temp = q->front;
    q->front = q->front->next;
    if (q->front == NULL) {
        q->rear = NULL;
    }
    free(temp);
}

void printQueue(struct Queue* q) {
    struct Node* temp = q->front;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}

int main() {
    // Create queue and perform operations
    // Your code here
}

Hint

Remember to enqueue 10, 20, 30 in order, then dequeue once, and finally print the queue.

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