Queue Operations

Picture the line at a coffee shop. The person who came first gets served first. A new person joins at the back and waits their turn. A queue in code works just like that line. So the real question is, how do we actually use it? What can we do to a queue? That is what this page is about. We will go through every basic move you can make on a queue, one at a time.

A queue follows FIFO, which means First In First Out. The first item you put in is the first one to come out. So all our operations respect that one rule.

🎯 The Core Queue Operations

Before we touch any code, let me show you the small set of moves a queue gives you. That is all a queue really is. Just a few simple operations.

Here is the list:

• enqueue — add an item to the back of the queue.
• dequeue — remove the item from the front and give it back.
• front (also called peek) — look at the front item without removing it.
• isEmpty — check if the queue has nothing in it.
• size — count how many items are waiting.

That is the whole toolkit. Let us walk through each one and see the steps.

📥 Enqueue: Add to the Back

Enqueue means you add a new item. It always goes to the back of the queue, never the middle, never the front. Just like a new person joining the end of the coffee shop line.

Think about the pain this solves. Items keep coming in and you need to serve them in the same order they arrived. Enqueue is how a new item joins the line and waits its turn.

Steps to enqueue an item:

1. Take the new item you want to add.
2. Place it right after the current last item.
3. The back of the queue now points to this new item.
4. The size goes up by one.

Here is a small picture of three enqueues happening one after another.

The item 10 came first so it sits at the front. The item 30 came last so it waits at the back.

📤 Dequeue: Remove from the Front

Dequeue is the opposite. You take the item out from the front, because that item has been waiting the longest. It came first, so it leaves first. After it leaves, the next item becomes the new front.

Steps to dequeue an item:

1. First check if the queue is empty. If it is, there is nothing to remove.
2. Look at the front item.
3. Remove it and hold its value to return.
4. Move the front to the next item.
5. The size goes down by one.

👀 Front, isEmpty and Size

These three are the smaller helpers. They do not change the queue. They just tell you something about it.

• front gives you the value at the front without removing it. This is handy when you want to see who is next but not serve them yet.
• isEmpty returns true when the queue has no items. You call this before every dequeue to stay safe.
• size tells you how many items are sitting in the queue right now.

None of these touch the order. They only read.

💻 Queue Operations in Code

Now let us see it run. Most languages already give you a ready-made queue, so we will use the built-in one where we can. We will enqueue a few numbers, peek at the front, dequeue a couple, and print the size along the way.

In C there is no built-in queue. So we use a simple array with a front and rear index. The other languages have proper queue types we can use directly.

#include <stdio.h>
#define MAX 100

// A simple array-based queue with front and rear indexes
int queue[MAX];
int front = 0;
int rear = 0;

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

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

// peek: read the front item without removing it
int peek() {
    return queue[front];
}

// isEmpty: true when front has caught up to rear
int isEmpty() {
    return front == rear;
}

// size: how many items are waiting
int size() {
    return rear - front;
}

int main() {
    enqueue(10);
    enqueue(20);
    enqueue(30);
    printf("Front item: %d\n", peek());
    printf("Size: %d\n", size());
    printf("Dequeued: %d\n", dequeue());
    printf("Dequeued: %d\n", dequeue());
    printf("Front item: %d\n", peek());
    printf("Size: %d\n", size());
    printf("Is empty: %d\n", isEmpty());
    return 0;
}

Front item: 10
Size: 3
Dequeued: 10
Dequeued: 20
Front item: 30
Size: 1
Is empty: 0

#include <iostream>
#include <queue>
using namespace std;

int main() {
    // std::queue gives us a ready-made FIFO queue
    queue<int> q;

    // enqueue with push: adds to the back
    q.push(10);
    q.push(20);
    q.push(30);

    // front reads the front item without removing it
    cout << "Front item: " << q.front() << endl;
    cout << "Size: " << q.size() << endl;

    // pop removes the front item, but does not return it
    cout << "Dequeued: " << q.front() << endl;
    q.pop();
    cout << "Dequeued: " << q.front() << endl;
    q.pop();

    cout << "Front item: " << q.front() << endl;
    cout << "Size: " << q.size() << endl;
    cout << "Is empty: " << q.empty() << endl;
    return 0;
}

Front item: 10
Size: 3
Dequeued: 10
Dequeued: 20
Front item: 30
Size: 1
Is empty: 0

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

public class QueueOperations {
    public static void main(String[] args) {
        // Queue is an interface, LinkedList is a common implementation
        Queue<Integer> q = new LinkedList<>();

        // offer adds an item to the back
        q.offer(10);
        q.offer(20);
        q.offer(30);

        // peek reads the front item without removing it
        System.out.println("Front item: " + q.peek());
        System.out.println("Size: " + q.size());

        // poll removes and returns the front item
        System.out.println("Dequeued: " + q.poll());
        System.out.println("Dequeued: " + q.poll());

        System.out.println("Front item: " + q.peek());
        System.out.println("Size: " + q.size());
        System.out.println("Is empty: " + q.isEmpty());
    }
}

Front item: 10
Size: 3
Dequeued: 10
Dequeued: 20
Front item: 30
Size: 1
Is empty: false

from collections import deque

# deque is the recommended way to make a queue in Python
q = deque()

# append adds an item to the back (enqueue)
q.append(10)
q.append(20)
q.append(30)

# q[0] reads the front item without removing it
print("Front item:", q[0])
print("Size:", len(q))

# popleft removes and returns the front item (dequeue)
print("Dequeued:", q.popleft())
print("Dequeued:", q.popleft())

print("Front item:", q[0])
print("Size:", len(q))
print("Is empty:", len(q) == 0)

Front item: 10
Size: 3
Dequeued: 10
Dequeued: 20
Front item: 30
Size: 1
Is empty: False

// A plain array can act as a queue
const q = [];

// push adds an item to the back (enqueue)
q.push(10);
q.push(20);
q.push(30);

// q[0] reads the front item without removing it
console.log("Front item:", q[0]);
console.log("Size:", q.length);

// shift removes and returns the front item (dequeue)
console.log("Dequeued:", q.shift());
console.log("Dequeued:", q.shift());

console.log("Front item:", q[0]);
console.log("Size:", q.length);
console.log("Is empty:", q.length === 0);

Front item: 10
Size: 3
Dequeued: 10
Dequeued: 20
Front item: 30
Size: 1
Is empty: false

⏱️ How Fast Are These Operations?

The good news is that a proper queue is fast. With the right setup, adding and removing both take constant time. Constant time means the work does not grow even when the queue gets huge. We write that as O(1).

Here is each operation and its cost.

⚠️ Common Mistakes to Avoid

A few small slips trip up almost everyone at the start. Watch out for these.

• Dequeuing without checking isEmpty first. This causes underflow and can crash your program.
• Mixing up front and back. Remember, items join at the back and leave from the front.
• Using shift() on a giant JavaScript array and wondering why it got slow. That front removal is O(n).
• Forgetting that peek and front only look. They do not remove anything.
• Thinking size changes the queue. It only counts. It never touches the items.

🧩 What You’ve Learned

✅ A queue follows FIFO, so the first item in is the first item out.

✅ The core operations are enqueue, dequeue, front, isEmpty and size.

✅ Enqueue adds to the back, and dequeue removes from the front.

✅ Always check isEmpty before a dequeue to avoid underflow.

✅ Most languages have a built-in queue you can use directly.

✅ With a proper queue, enqueue and dequeue both run in O(1) constant time.

🚀 What’s Next?

• Introduction to Queue
• Queue Using Array