Enqueue Operation in DSA C

Mental Model

Adding an item to the end of a queue means putting it behind all the others waiting in line.

Analogy: Imagine a line of people waiting to buy tickets. When a new person arrives, they go to the very end of the line.

front -> null
rear -> null
queue is empty

Dry Run Walkthrough

Input: queue initially empty, enqueue values 10, then 20

Goal: Add new values to the end of the queue, maintaining order

Step 1: enqueue 10 into empty queue

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

Why: First element becomes both front and rear because queue was empty

Step 2: enqueue 20 at the rear

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

Why: New element added after rear, rear pointer updated to new node

Result:

front -> 10 -> 20 -> null
rear -> 20

Annotated Code

DSA C

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

// Node structure for queue
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 a new empty queue
Queue* createQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = NULL;
    q->rear = NULL;
    return q;
}

// Enqueue operation: add value 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, new node is front and rear
        q->front = newNode;
        q->rear = newNode;
        return;
    }

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

// Print queue 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);

    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 after current rear

q->rear = newNode;

update rear pointer to new node

Output

10 -> 20 -> null

Complexity Analysis

Time: O(1) because enqueue adds at rear without traversing the queue

Space: O(1) because only one new node is created per enqueue

vs Alternative: Compared to array-based queue with shifting, linked list enqueue is faster as it avoids moving elements

Edge Cases

empty queue

new node becomes both front and rear

DSA C

if (q->rear == NULL) {

When to Use This Pattern

When you need to add items in order to a waiting line structure, use enqueue to add at the end efficiently.

Common Mistakes

Mistake: Not updating rear pointer after adding new node
Fix: Always set rear to the new node after linking it

Mistake: Not handling empty queue case separately
Fix: Check if rear is NULL and set front and rear to new node

Summary

Adds a new element to the end of the queue.

Use when you want to maintain order and add items at the back of a waiting line.

Remember to update both rear pointer and handle empty queue case.

Practice

1. What does the enqueue operation do in a queue data structure?

easy

A. Adds an element to the rear of the queue

B. Removes an element from the front of the queue

C. Checks if the queue is empty

D. Returns the size of the queue

Solution

1. Step 1: Understand the queue operations

   In a queue, enqueue means adding an element, while dequeue means removing one.

2. Step 2: Identify the position of addition

   Elements are always added at the rear (end) of the queue during enqueue.

3. Final Answer:

   Adds an element to the rear of the queue -> Option A

4. Quick Check:

   Enqueue = Add rear [OK]

Hint: Enqueue always adds at the back of the queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue operation
• Thinking enqueue removes elements
• Assuming enqueue adds at the front

2. Which of the following is the correct syntax to enqueue an element 10 in a queue implemented using an array named queue with rear index rear in C?

easy

A. queue[rear] = ++10;

B. queue[rear++] = 10;

C. queue[rear] = 10++;

D. queue[++rear] = 10;

Solution

1. Step 1: Understand post-increment vs pre-increment

   Post-increment (rear++) uses rear as index then increments it. Pre-increment (++rear) increments rear first then uses it as index.

2. Step 2: Choose correct index update for enqueue

   To add at current rear position and then move rear forward, use post-increment: queue[rear++] = 10;.

3. Final Answer:

   queue[rear++] = 10; -> Option B

4. Quick Check:

   Post-increment rear after assignment [OK]

Hint: Use rear++ to assign then move rear forward [OK]

Common Mistakes:

• Using pre-increment causing skip of first index
• Trying to increment the value instead of index
• Syntax errors with invalid increments

3. What will be the state of the queue array after executing the following code?

int queue[5];
int rear = -1;
queue[++rear] = 5;
queue[++rear] = 10;
queue[++rear] = 15;

medium

A. [5, 10, 0, 15, 0]

B. [0, 5, 10, 15, 0]

C. [5, 10, 15, 0, 0]

D. [15, 10, 5, 0, 0]

Solution

1. Step 1: Trace each enqueue operation

   Initially, rear = -1.
   First enqueue: ++rear = 0, queue[0] = 5.
   Second enqueue: ++rear = 1, queue[1] = 10.
   Third enqueue: ++rear = 2, queue[2] = 15.

2. Step 2: Determine final queue array state

   Positions 0,1,2 have 5,10,15 respectively. Others remain 0 (default uninitialized).

3. Final Answer:

   [5, 10, 15, 0, 0] -> Option C

4. Quick Check:

   Enqueue adds sequentially at indices 0,1,2 [OK]

Hint: Pre-increment rear before assignment fills array from index 0 [OK]

Common Mistakes:

• Confusing post-increment with pre-increment
• Assuming queue starts at index 1
• Ignoring initial rear value -1

4. Identify the error in the following enqueue function for a queue implemented using an array and fix it:

void enqueue(int queue[], int *rear, int value) {
    queue[*rear] = value;
    (*rear)++;
}

medium

A. The value should be assigned after incrementing rear twice

B. The rear should not be incremented at all

C. The function should decrement rear instead

D. The rear should be incremented before assignment

Solution

1. Step 1: Analyze the enqueue logic

   The function assigns value at current rear index, then increments rear.
   This causes the first element to be placed at rear=0 if rear was 0, which is correct only if rear points to next free slot.

2. Step 2: Correct the order for standard enqueue

   Usually, rear points to last filled index, so increment rear first, then assign:
   queue[++(*rear)] = value;.

3. Final Answer:

   The rear should be incremented before assignment -> Option D

4. Quick Check:

   Increment rear first, then assign value [OK]

Hint: Increment rear before assignment to avoid overwrite [OK]

Common Mistakes:

• Assigning value before incrementing rear
• Incrementing rear twice accidentally
• Decrementing rear instead of incrementing

5. Given a circular queue of size 5 with front = 3 and rear = 1, which of the following enqueue operations is valid and will not cause overflow?

hard

A. Enqueue at rear = 2

B. Enqueue at rear = 3

C. Enqueue at rear = 4

D. Enqueue at rear = 0

Solution

1. Step 1: Understand circular queue indexing

   Queue size = 5, indices 0 to 4.
   front = 3, rear = 1 means elements occupy positions from front to rear wrapping around.

2. Step 2: Check next rear position for enqueue

   Next rear = (rear + 1) % size = (1 + 1) % 5 = 2.
   If next rear equals front, queue is full (overflow). Here, next rear 2 != front 3, so enqueue at 2 is valid.
   But options show enqueue at rear = 2, 3, 4, 0. We must check which is correct next rear.

3. Step 3: Validate each option

   Enqueue at rear = 2: rear=2 is next rear, valid.
   Enqueue at rear = 3: rear=3 equals front, overflow.
   Enqueue at rear = 4: rear=4 is not next rear, invalid.
   Enqueue at rear = 0: rear=0 is not next rear, invalid.

4. Final Answer:

   Enqueue at rear = 2 -> Option A

5. Quick Check:

   Next rear = (rear+1)%size = 2, enqueue valid [OK]

Hint: Next rear = (rear + 1) mod size; must not equal front [OK]

Common Mistakes:

• Ignoring circular wrap-around logic
• Enqueueing at front index causing overflow
• Assuming rear can be any index