Queue using C

What is a queue? (FIFO)

A queue is a data structure that follows one simple rule: FIFO — First In, First Out. The item that goes in first is the first to come out.

Think of a line at a ticket counter. The person who arrives first is served first; new people join at the back. A queue in C works exactly like that line — you add at one end and remove from the other. (Compare this with the stack in C, which is LIFO.)

The core operations

Full and empty conditions

• Empty — no items to remove (front is greater than rear, or both start at -1/0 depending on the style).
• Full — rear has reached the last index, so there is no room to enqueue.

Array implementation

#include <stdio.h>
#define SIZE 5
int queue[SIZE];
int front = 0, rear = -1, count = 0;

void enqueue(int x) {
    if (count == SIZE) { printf("Queue full\n"); return; }
    rear = (rear + 1);
    queue[rear] = x;
    count++;
}
int dequeue() {
    if (count == 0) { printf("Queue empty\n"); return -1; }
    int val = queue[front];
    front++;
    count--;
    return val;
}
int main() {
    enqueue(10); enqueue(20); enqueue(30);
    printf("Removed: %d\n", dequeue());  // 10 (first in)
    printf("Removed: %d\n", dequeue());  // 20
    return 0;
}

Notice 10 came out first because it went in first — that is FIFO, the opposite of a stack.

Queue vs stack

Common mistakes

• Removing from the wrong end — a queue removes from the front, not the rear.
• Not checking full before enqueue or empty before dequeue.
• Ignoring wasted space in a simple array queue (use a circular queue to fix it).
• Forgetting to update front, rear or the count after each operation.

Summary

• A queue follows FIFO — the first item in is the first out.
• enqueue adds at the rear; dequeue removes from the front.
• Track positions with front and rear (and often a count).
• Check full before enqueue and empty before dequeue.
• A circular queue reuses freed space; a stack is the LIFO counterpart.