Queue Concept and FIFO Principle in DSA C - Execution Trace

Concept Flow - Queue Concept and FIFO Principle

Start

↓

Enqueue: Add item at rear

↓

Queue State Updated

↓

Dequeue: Remove item from front

↓

Queue State Updated

↓

Repeat Enqueue/Dequeue as needed

↓

End

The queue adds items at the rear and removes items from the front, following the FIFO order.

Execution Sample

DSA C

enqueue(10)
enqueue(20)
dequeue()
enqueue(30)
dequeue()

This code adds 10 and 20 to the queue, removes one item, adds 30, then removes another item, showing FIFO behavior.

Execution Table

Step	Operation	Nodes in Queue	Pointer Changes	Visual State
1	enqueue(10)	10	rear -> 10, front -> 10	10 -> null
2	enqueue(20)	10, 20	rear -> 20, front -> 10	10 -> 20 -> null
3	dequeue()	20	front -> 20, rear -> 20	20 -> null
4	enqueue(30)	20, 30	rear -> 30, front -> 20	20 -> 30 -> null
5	dequeue()	30	front -> 30, rear -> 30	30 -> null
6	End	30	No change	30 -> null

💡 No more operations; queue ends with one element 30.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
front	null	10	10	20	20	30	30
rear	null	10	20	20	30	30	30
queue size	0	1	2	1	2	1	1

Key Moments - 3 Insights

Why does dequeue remove from the front and not the rear?

Because queue follows FIFO, the first item added (front) must be removed first. See execution_table step 3 where front moves from 10 to 20 after dequeue.

What happens to pointers when the queue has only one element?

Both front and rear point to the same node. For example, after step 1 and step 5, front and rear both point to the single element.

Why does enqueue add at the rear and not the front?

To maintain FIFO order, new items join at the rear. See step 2 and 4 where rear pointer moves forward to new nodes.

Visual Quiz - 3 Questions

Look at the execution_table, what is the queue state after step 3?

A 20 -> null

B 10 -> 20 -> null

C 10 -> null

D null

💡 Hint

Check the 'Visual State' column for step 3 in execution_table.

At which step does the rear pointer move to the node with value 30?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at 'Pointer Changes' column in execution_table for when rear points to 30.

If we dequeue twice at the start, what will be the queue size after step 3?

A 2

B 1

C 0

D 3

💡 Hint

Refer to variable_tracker 'queue size' after dequeue operations.

Concept Snapshot

Queue stores items in order.
Enqueue adds at rear.
Dequeue removes from front.
Follows FIFO: first in, first out.
Pointers front and rear track ends.
Empty queue has front and rear null.

Full Transcript

A queue is a data structure where items are added at the rear and removed from the front. This follows the FIFO principle, meaning the first item added is the first to be removed. We track two pointers: front points to the first item, rear points to the last. When we enqueue, we add a new node at rear and move rear pointer. When we dequeue, we remove the node at front and move front pointer. If the queue has one item, front and rear point to the same node. The example code enqueues 10 and 20, dequeues one item (removing 10), enqueues 30, then dequeues again (removing 20). The queue ends with one item 30. This shows how the queue maintains order and updates pointers step by step.