Queue Concept and FIFO Principle in DSA C - Build from Scratch

Queue Concept and FIFO Principle

📖 Scenario: Imagine a ticket counter where people stand in a line. The first person to arrive is the first to get the ticket and leave. This is called FIFO - First In, First Out. We will create a simple queue to simulate this line.

🎯 Goal: Build a queue using an array in C that follows the FIFO principle. You will add people to the queue and remove them in the order they arrived.

📋 What You'll Learn

Create an integer array called queue with size 5

Create two integer variables front and rear to track the queue ends

Write a function enqueue to add an element to the queue

Write a function dequeue to remove an element from the queue

Print the queue elements after enqueue and dequeue operations

💡 Why This Matters

🌍 Real World

Queues are used in real life for lines at stores, printers, and task scheduling where order matters.

💼 Career

Understanding queues helps in software development for managing tasks, requests, and resources efficiently.

1

Create the queue array and initialize pointers

Create an integer array called queue with size 5. Also create two integer variables called front and rear. Initialize front to -1 and rear to -1.

DSA C

int queue[5];
int front = -1;
int rear = -1;
// Your code here

Hint

Think of front and rear as markers for the start and end of the line.

2

Add the enqueue function to add elements

Write a function called enqueue that takes an integer value and adds it to the queue. Inside the function, first check if rear is 4 (queue full). If full, print "Queue is full". Otherwise, increase rear by 1 and add value to queue[rear]. If front is -1, set it to 0.

DSA C

void enqueue(int value) {
    // Your code here
}

Hint

Remember to check if the queue is full before adding.

3

Add the dequeue function to remove elements

Write a function called dequeue that removes and returns the front element from the queue. If front is -1 or greater than rear, print "Queue is empty" and return -1. Otherwise, store queue[front] in a variable, increase front by 1, and return the stored value.

DSA C

int dequeue() {
    // Your code here
}

Hint

Check if the queue is empty before removing an element.

4

Test the queue by enqueueing and dequeueing

In the main function, enqueue the values 10, 20, and 30 using enqueue. Then dequeue one value and print it with printf. Finally, print the remaining queue elements from front to rear using a for loop.

DSA C

int main() {
    // Your code here
    return 0;
}

Hint

Use a loop from front to rear to print the queue elements.

Practice

1. What does FIFO stand for in the context of a queue?

easy

A. First Input, First Operation

B. First In, Final Out

C. Fast Input, Fast Output

D. First In, First Out

Solution

1. Step 1: Understand FIFO meaning

   FIFO means the first element added to the queue is the first one to be removed.

2. Step 2: Match the acronym

   First In, First Out exactly describes this behavior.

3. Final Answer:

   First In, First Out -> Option D

4. Quick Check:

   FIFO = First In, First Out [OK]

Hint: Remember queue removes oldest item first [OK]

Common Mistakes:

• Confusing FIFO with LIFO
• Thinking FIFO means last added first removed
• Mixing up acronym letters

2. Which of the following is the correct syntax to enqueue an element `x` into a queue named `q` in C?

easy

A. push(q, x);

B. enqueue(q, x);

C. q.enqueue(x);

D. q.add(x);

Solution

1. Step 1: Identify common C queue operation

   In C, queue operations are usually functions like enqueue(queue, element).

2. Step 2: Check options for C style

   enqueue(q, x); uses function call syntax typical in C. Others use object-oriented syntax not common in C.

3. Final Answer:

   enqueue(q, x); -> Option B

4. Quick Check:

   C queue enqueue = enqueue(q, x); [OK]

Hint: C uses function calls, not dot notation [OK]

Common Mistakes:

• Using object-oriented syntax in C
• Confusing push with enqueue
• Using wrong function names

3. Consider the following C code snippet using a queue:

enqueue(q, 10);
enqueue(q, 20);
dequeue(q);
enqueue(q, 30);
dequeue(q);

What is the next element to be dequeued?

medium

A. 30

B. 10

C. 20

D. Queue is empty

Solution

1. Step 1: Trace enqueue and dequeue operations

   Queue after enqueue 10 and 20: [10, 20]. Dequeue removes 10, queue: [20]. Enqueue 30: [20, 30]. Dequeue removes 20, queue: [30].

2. Step 2: Identify next element to dequeue

   Next element is the front of queue, which is 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Queue front after operations = 30 [OK]

Hint: Follow FIFO order step-by-step [OK]

Common Mistakes:

• Assuming last enqueued is dequeued next
• Forgetting previous dequeues
• Mixing enqueue and dequeue order

4. Identify the error in the following C code snippet for queue operations:

enqueue(q, 5);
dequeue(q);
dequeue(q);

Assuming the queue was initially empty.

medium

A. Second dequeue causes underflow error

B. No error, code runs fine

C. First enqueue is incorrect syntax

D. Queue overflow error occurs

Solution

1. Step 1: Analyze queue state after operations

   Initially empty queue. Enqueue 5 adds one element. First dequeue removes it, queue empty again.

2. Step 2: Check second dequeue

   Second dequeue tries to remove from empty queue, causing underflow error.

3. Final Answer:

   Second dequeue causes underflow error -> Option A

4. Quick Check:

   Dequeue empty queue = underflow error [OK]

Hint: Check if queue is empty before dequeue [OK]

Common Mistakes:

• Ignoring empty queue before dequeue
• Confusing overflow with underflow
• Assuming enqueue syntax error

5. You have a queue that can hold a maximum of 3 elements. The following operations are performed:

enqueue(q, 1);
enqueue(q, 2);
enqueue(q, 3);
dequeue(q);
enqueue(q, 4);
dequeue(q);
dequeue(q);

What is the state of the queue after these operations?

hard

A. Queue is empty

B. 3 -> 4 -> null

C. 4 -> null

D. 2 -> 3 -> 4 -> null

Solution

1. Step 1: Track queue after each operation

   Enqueue 1,2,3: queue = [1,2,3]. Dequeue removes 1: queue = [2,3]. Enqueue 4: queue = [2,3,4]. Dequeue removes 2: queue = [3,4]. Dequeue removes 3: queue = [4].

2. Step 2: Final queue state

   Only element left is 4, so queue is 4 -> null.

3. Final Answer:

   4 -> null -> Option C

4. Quick Check:

   Final queue front = 4 [OK]

Hint: Follow enqueue and dequeue stepwise, watch max size [OK]

Common Mistakes:

• Forgetting max size limit
• Miscounting dequeues
• Assuming queue empty incorrectly