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

Queue Concept and FIFO Principle

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

🎯 Goal: Build a simple queue using an array to add people to the line and remove them in the order they arrived, demonstrating the FIFO principle.

📋 What You'll Learn

Create an array to hold the queue elements

Use variables to track the front and rear of the queue

Add elements to the queue in order

Remove elements from the queue in FIFO order

Print the queue after operations

💡 Why This Matters

🌍 Real World

Queues are used in real life for lines at stores, printers, and call centers where the first person to arrive is served first.

💼 Career

Understanding queues helps in software development for managing tasks, requests, and resources in the correct order.

1

Create the queue array and initialize front and rear

Create an integer array called queue with size 5. Create two integer variables called front and rear. Set front to 0 and rear to -1.

DSA Java

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

Hint

Use int[] queue = new int[5]; to create the array. Initialize front and rear as described.

2

Add three people to the queue

Increase rear by 1 and add the values 10, 20, and 30 to the queue array at positions rear. Do this three times to add three people.

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] queue = new int[5];
        int front = 0;
        int rear = -1;
        // Add 10, 20, 30 to queue
        // Your code here
    }
}

Hint

Use rear++ before adding each value to move the rear forward.

3

Remove one person from the queue using FIFO

Increase front by 1 to remove the first person from the queue, simulating FIFO removal.

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] queue = new int[5];
        int front = 0;
        int rear = -1;
        rear++;
        queue[rear] = 10;
        rear++;
        queue[rear] = 20;
        rear++;
        queue[rear] = 30;
        // Remove one person from queue
        // Your code here
    }
}

Hint

Use front++ to move the front forward, removing the first element.

4

Print the current queue elements from front to rear

Use a for loop with variable i from front to rear inclusive. Inside the loop, print each queue[i] followed by a space. After the loop, print a new line.

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] queue = new int[5];
        int front = 0;
        int rear = -1;
        rear++;
        queue[rear] = 10;
        rear++;
        queue[rear] = 20;
        rear++;
        queue[rear] = 30;
        front++;
        // Print queue elements from front to rear
        // Your code here
    }
}

Hint

Use a for loop from front to rear and print each element with a space.

Practice

1. What does the FIFO principle mean in the context of a queue?

easy

A. Last In, First Out - the last element added is the first removed

B. First In, Last Out - the first element added is the last removed

C. First In, First Out - the first element added is the first removed

D. Last In, Last Out - the last element added is the last removed

Solution

1. Step 1: Understand FIFO meaning

   FIFO means the first element that enters the queue is the first to leave.

2. Step 2: Match FIFO to queue behavior

   Queues follow FIFO, so the first added element is removed first.

3. Final Answer:

   First In, First Out - the first element added is the first removed -> Option C

4. Quick Check:

   FIFO = First In, First Out [OK]

Hint: Remember queue = line; first come, first served [OK]

Common Mistakes:

• Confusing FIFO with LIFO
• Thinking queue removes last added first
• Mixing stack behavior with queue

2. Which of the following is the correct way to add an element to a Java Queue named q?

easy

A. q.add(10);

B. q.enqueue(10);

C. q.push(10);

D. q.insert(10);

Solution

1. Step 1: Recall Java Queue methods

   Java Queue interface uses add() or offer() to add elements.

2. Step 2: Identify correct method

   push() and enqueue() are not Queue methods; insert() is invalid.

3. Final Answer:

   q.add(10); -> Option A

4. Quick Check:

   Use add() to insert in Java Queue [OK]

Hint: Use add() or offer() to add in Java Queue [OK]

Common Mistakes:

• Using push() which is for stacks
• Using enqueue() which is not a Java Queue method
• Using insert() which does not exist in Queue

3. What will be the output of the following Java code?

import java.util.*;
public class Main {
  public static void main(String[] args) {
    Queue<Integer> q = new LinkedList<>();
    q.add(5);
    q.add(10);
    q.add(15);
    System.out.print(q.poll() + " -> ");
    System.out.print(q.poll() + " -> ");
    System.out.print(q.poll() + " -> ");
  }
}

medium

A. 15 -> 10 -> 5 ->

B. 5 -> 10 -> 15 ->

C. 10 -> 15 -> 5 ->

D. 5 -> 15 -> 10 ->

Solution

1. Step 1: Add elements to queue

   Elements 5, 10, 15 are added in order to the queue.

2. Step 2: Remove elements using poll()

   poll() removes elements in FIFO order: 5, then 10, then 15.

3. Final Answer:

   5 -> 10 -> 15 -> -> Option B

4. Quick Check:

   Queue poll() removes in FIFO order [OK]

Hint: poll() removes first added element in queue [OK]

Common Mistakes:

• Thinking poll() removes last element
• Confusing queue with stack order
• Assuming poll() does not remove element

4. Identify the error in the following Java code snippet using a Queue:

Queue<String> q = new LinkedList<>();
q.add("apple");
q.add("banana");
String first = q.remove();
String second = q.remove();
String third = q.remove();

medium

A. No error, code runs fine

B. remove() method does not exist in Queue

C. Queue cannot store Strings

D. Third remove() causes NoSuchElementException

Solution

1. Step 1: Check number of elements added

   Only two elements "apple" and "banana" are added to the queue.

2. Step 2: Analyze remove() calls

   First two remove() calls remove "apple" and "banana". Third remove() tries to remove from empty queue causing exception.

3. Final Answer:

   Third remove() causes NoSuchElementException -> Option D

4. Quick Check:

   Removing from empty queue throws exception [OK]

Hint: Removing more than added elements causes exception [OK]

Common Mistakes:

• Assuming remove() returns null if empty
• Thinking queue can't store Strings
• Believing remove() method is missing

5. You have a queue that stores customer IDs in order of arrival. You want to process customers but skip any ID that is negative (invalid). Which approach correctly processes the queue while maintaining FIFO order and skipping negatives?

Queue<Integer> q = new LinkedList<>();
// Assume q is filled with IDs including negatives
while (!q.isEmpty()) {
  int id = q.poll();
  // What to do here?
}

hard

A. If id is negative, ignore and continue; else process it

B. If id is negative, remove all remaining elements

C. If id is negative, stop processing the queue

D. If id is negative, add it back to the end of the queue

Solution

1. Step 1: Understand queue processing with condition

   We want to skip negative IDs but keep processing others in order.

2. Step 2: Choose correct action for negative IDs

   Ignoring negative IDs and continuing preserves FIFO order and processes valid IDs only.

3. Final Answer:

   If id is negative, ignore and continue; else process it -> Option A

4. Quick Check:

   Skip negatives, process others in FIFO [OK]

Hint: Skip invalid IDs, don't re-add or stop queue [OK]

Common Mistakes:

• Re-adding negative IDs causing infinite loop
• Stopping queue on first negative ID
• Removing all elements on negative ID