Enqueue Operation in DSA C - Execution Trace

Concept Flow - Enqueue Operation

Create new node with data

↓

Is queue empty?

Yes→Set head and tail to new node

No↓

Set tail.next to new node

↓

Update tail to new node

↓

Done

This flow shows how a new node is created and added at the end of the queue, updating pointers accordingly.

Execution Sample

DSA C

void enqueue(Queue* q, int value) {
    Node* newNode = malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    if (q->tail == NULL) {
        q->head = newNode;
        q->tail = newNode;
    } else {
        q->tail->next = newNode;
        q->tail = newNode;
    }
}

This code adds a new element at the end of the queue, updating head and tail pointers.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create new node with data=10	None	newNode created	null
2	Check if queue is empty (tail == NULL)	None	tail is NULL (empty queue)	null
3	Set head and tail to newNode	10	head -> newNode, tail -> newNode	10 -> null
4	Create new node with data=20	10	newNode created	10 -> null
5	Check if queue is empty (tail == NULL)	10	tail not NULL	10 -> null
6	Set tail->next to newNode	10, 20	tail->next -> newNode	10 -> 20 -> null
7	Update tail to newNode	10, 20	tail -> newNode	10 -> 20 -> null
8	Create new node with data=30	10, 20	newNode created	10 -> 20 -> null
9	Check if queue is empty (tail == NULL)	10, 20	tail not NULL	10 -> 20 -> null
10	Set tail->next to newNode	10, 20, 30	tail->next -> newNode	10 -> 20 -> 30 -> null
11	Update tail to newNode	10, 20, 30	tail -> newNode	10 -> 20 -> 30 -> null
12	End of enqueue operations	10, 20, 30	head -> 10, tail -> 30	10 -> 20 -> 30 -> null

💡 All enqueue operations completed; tail updated to last node; queue is not empty.

Variable Tracker

Variable	Start	After Step 3	After Step 7	After Step 11	Final
head	NULL	Node(10)	Node(10)	Node(10)	Node(10)
tail	NULL	Node(10)	Node(20)	Node(30)	Node(30)
newNode	NULL	Node(10)	Node(20)	Node(30)	NULL
Queue Size	0	1	2	3	3

Key Moments - 3 Insights

Why do we check if tail is NULL before adding a new node?

Because if tail is NULL, the queue is empty, so both head and tail must point to the new node. This is shown in execution_table step 2 and 3.

Why do we set tail->next to the new node when queue is not empty?

Because the new node must be linked after the current tail to maintain the queue order. This happens in steps 6 and 10.

Why do we update tail to the new node after linking it?

Because tail always points to the last node in the queue, so after adding a new node, tail must move to it. See steps 7 and 11.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does the queue look like?

A null

B 10 -> null

C 20 -> null

D 10 -> 20 -> null

💡 Hint

Check the Visual State column at step 3 in execution_table.

At which step does the tail pointer first move from NULL to a node?

A Step 3

B Step 6

C Step 1

D Step 7

💡 Hint

Look at Pointer Changes column to see when tail changes from NULL.

If we enqueue a new node after step 11, what will tail point to?

A Node with data 10

B Node with data 30

C Newly created node

D Node with data 20

💡 Hint

Tail always points to the last node added, see variable_tracker after step 11.

Concept Snapshot

Enqueue Operation in Queue:
- Create new node with data
- If queue empty (tail == NULL), set head and tail to new node
- Else, link new node after tail (tail->next = new node)
- Update tail to new node
- Queue grows at tail end maintaining FIFO order

Full Transcript

The enqueue operation adds a new element at the end of the queue. First, a new node is created with the given data. If the queue is empty, both head and tail pointers are set to this new node. Otherwise, the current tail's next pointer is set to the new node, and then tail is updated to point to the new node. This maintains the order of elements in the queue, ensuring FIFO behavior. The execution table shows each step of this process, including pointer updates and the visual state of the queue. The variable tracker records how head, tail, and newNode pointers change after each operation. Key moments clarify why checking for an empty queue is necessary and why tail must be updated after adding a node. The visual quiz tests understanding of these steps and pointer changes.

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