Introduction to Queue

Picture this. You go to a movie theater to buy tickets. There is a line in front of the counter. The person who came first stands at the front and gets served first. You came last. So you stand at the back and wait your turn. Nobody jumps the line. That simple idea is exactly what a queue is in programming.

A queue is a way to store items where the first item you add is the first item you take out. We call this rule FIFO. It means First-In-First-Out. So the order is fair. Whoever came first leaves first.

🎬 A Real-World Analogy

Think about that ticket counter line one more time.

• New people join at the rear of the line. The rear is the back.
• The person at the front gets the ticket and leaves.
• Service happens in the same order people arrived.

So the line only grows at the back. And it only shrinks at the front. A queue in code works the exact same way. You add at one end and remove from the other end.

🤔 Why Do We Need a Queue?

Here is the pain. Sometimes you have a bunch of jobs waiting. And you must handle them in the order they arrived. If you grab a random job, things become unfair and messy. A queue solves this. It keeps the arrival order for you. So the oldest waiting job is always the next one you handle.

You see queues all around you in real software.

• Printer jobs line up. Ten people send documents to one printer. The first document sent is the first one printed.
• The operating system schedules tasks. It lines them up and runs them in turn.
• BFS uses a queue. BFS means Breadth-First Search. It is a way to search a graph or tree by exploring neighbors level by level. The queue remembers which node to visit next.
• Customer support uses a queue too. Messages get answered in the order they came in.

🔧 The Four Core Operations

A queue is simple. There are only a few things you ever do with it. Here is what each one means.

• enqueue — add a new item at the rear (the back). This is like a new person joining the line.
• dequeue — remove the item at the front and return it. This is like the front person getting served and leaving.
• front — look at the item at the front without removing it. Just peek. Don’t take.
• isEmpty — check if the queue has no items left. It returns true or false.

The word enqueue just means “put into the queue”. And dequeue means “take out of the queue”. Don’t let the names scare you. They are only fancy words for add and remove.

📊 How It Looks Step by Step

Let’s say we enqueue three numbers: 10, then 20, then 30. The front is on the left and the rear is on the right.

Now we call dequeue once. The front item 10 leaves first because it came first. What stays is 20 and 30. Now 20 is the new front.

See how the line shrinks from the front and grows from the rear? That is the whole idea of FIFO in one picture.

💻 A Tiny Queue Demo in Code

Let’s make a small queue. We add a few items. Then we remove them one by one. Most languages already give us a built-in tool for this. So we don’t have to build the queue from scratch yet. We just use it and watch the FIFO order in action.

Here we enqueue 10, 20, and 30. Then we peek at the front, dequeue twice, and check what is left.

#include <stdio.h>

#define SIZE 100

// A simple array-based queue with front and rear markers.
// Note: this basic version does not reuse slots after dequeue,
// since front and rear only move forward. A real queue uses a
// circular buffer so freed slots can be used again.
int queue[SIZE];
int front = 0; // index of the front item
int rear = 0;  // index where the next item goes

// Add an item at the rear
void enqueue(int value) {
    queue[rear] = value;
    rear++;
}

// Remove and return the front item
int dequeue() {
    int value = queue[front];
    front++;
    return value;
}

// Check if the queue has no items
int isEmpty() {
    return front == rear;
}

int main() {
    enqueue(10);
    enqueue(20);
    enqueue(30);

    printf("Front item: %d\n", queue[front]); // peek at front
    printf("Removed: %d\n", dequeue());       // 10 leaves first
    printf("Removed: %d\n", dequeue());       // then 20
    printf("New front: %d\n", queue[front]);  // 30 is left
    printf("Is empty? %s\n", isEmpty() ? "yes" : "no");

    return 0;
}

Front item: 10
Removed: 10
Removed: 20
New front: 30
Is empty? no

#include <iostream>
#include <queue> // built-in queue
using namespace std;

int main() {
    queue<int> q;

    // enqueue adds at the rear
    q.push(10);
    q.push(20);
    q.push(30);

    cout << "Front item: " << q.front() << endl; // peek at front
    cout << "Removed: " << q.front() << endl;     // 10 is at front
    q.pop();                                       // remove it
    cout << "Removed: " << q.front() << endl;     // now 20
    q.pop();
    cout << "New front: " << q.front() << endl;   // 30 is left
    cout << "Is empty? " << (q.empty() ? "yes" : "no") << endl;

    return 0;
}

Front item: 10
Removed: 10
Removed: 20
New front: 30
Is empty? no

import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {
    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();

        // enqueue adds at the rear
        q.add(10);
        q.add(20);
        q.add(30);

        System.out.println("Front item: " + q.peek()); // peek at front
        System.out.println("Removed: " + q.poll());     // 10 leaves first
        System.out.println("Removed: " + q.poll());     // then 20
        System.out.println("New front: " + q.peek());   // 30 is left
        System.out.println("Is empty? " + (q.isEmpty() ? "yes" : "no"));
    }
}

Front item: 10
Removed: 10
Removed: 20
New front: 30
Is empty? no

from collections import deque

# deque is a fast built-in we can use as a queue
queue = deque()

# enqueue adds at the rear
queue.append(10)
queue.append(20)
queue.append(30)

print("Front item:", queue[0])        # peek at front
print("Removed:", queue.popleft())    # 10 leaves first
print("Removed:", queue.popleft())    # then 20
print("New front:", queue[0])         # 30 is left
print("Is empty?", "yes" if not queue else "no")

Front item: 10
Removed: 10
Removed: 20
New front: 30
Is empty? no

// We use a normal array as a simple queue
const queue = [];

// enqueue adds at the rear with push
queue.push(10);
queue.push(20);
queue.push(30);

console.log("Front item:", queue[0]);        // peek at front
console.log("Removed:", queue.shift());      // 10 leaves first
console.log("Removed:", queue.shift());      // then 20
console.log("New front:", queue[0]);         // 30 is left
console.log("Is empty?", queue.length === 0 ? "yes" : "no");

Front item: 10
Removed: 10
Removed: 20
New front: 30
Is empty? no

Look at the output. The number 10 went in first and came out first. Then 20. That is FIFO working exactly like the ticket line.

⏱️ How Fast Are These Operations?

Good news. The main queue operations are very fast. They do not depend on how many items are inside. So each one runs in O(1) time. Here is a quick look at the time cost.

⚠️ Common Mistakes to Avoid

A few small slip-ups trip up beginners. Watch out for these.

• Removing from the wrong end. You always remove from the front, never from the rear.
• Forgetting to check isEmpty before dequeue. Removing from an empty queue causes an error called underflow.
• Mixing up queue and stack. Queue is FIFO, like a line of people. Stack is LIFO, like a pile of plates.
• In JavaScript, using shift() on a huge array can be slow. It moves every element each time. For real heavy work, a proper queue structure is better.

🧩 What You’ve Learned

✅ A queue is a FIFO structure. The first item added is the first one removed, just like a line at a ticket counter.

✅ You add items at the rear with enqueue and remove from the front with dequeue.

✅ The front operation lets you peek without removing. The isEmpty operation tells you if the queue has any items.

✅ Queues power real things like printer jobs, task scheduling, and BFS in graphs and trees.

✅ The core operations enqueue, dequeue, front, and isEmpty all run in O(1) time.

🚀 What’s Next?

Now you know what a queue is and how FIFO works. Next, go deeper into each operation. Then build a queue yourself.

• Queue Operations
• Queue Using Array