Section 3 — Data Structures

Queues & Circular Queues

Understand FIFO order, find the dead space a linear array wastes, and watch the modulo turn that same array into a ring.

C++ · Queue · Circular Queue · STL

Section 3 — Motivation

Why a Queue?

A queue decouples the producer from the consumer. Work often arrives faster than it can be served, so it waits in line — and it waits in arrival order.

RULEElements leave in the order they arrived — first in, first out.

ENQUEUEAdds at the rear — the back of the line.

DEQUEUERemoves from the front — the head of the line.

Both ends are fixed. Nothing is ever inserted in the middle, and nothing is ever reordered.

WHERE YOU MEET ONETHE QUEUE IS

Print spoolJobs wait for the printer in the order they were sent.

Ticket officeAlice joins first, so Alice is served first.

BFS frontierThe next node to visit is the one that arrived first.

BufferA burst of arrivals is held until the slow consumer catches up.

THE LINE AT THE TICKET OFFICELOOPING · FIRST IN, FIRST OUT

FRONT · DEPARTUREARRIVAL · REAR

102030

IN LINE · 310, 20 and 30 are waiting — in the order they arrived.

FIRST INNobody is ever moved up the line and nobody is ever reordered — the queue only ever decides who leaves next.

WHY A QUEUE EXISTSTHE PRODUCER NEVER WAITS FOR THE CONSUMER

Producer→Queue→Consumer

BURSTSWork that arrives faster than it can be served waits in the queue — and the producer is free to carry on.

Two Orders

Stack vs. Queue

STACKLIFO — last in, first out. A pile of plates: you always take the top one.

QUEUEFIFO — first in, first out. A line at a ticket office: you always take the front one.

Same data structure family, opposite contract. Choosing the wrong one is a bug, not a preference.

STACK

One end does everything. Both operations work on the same side, so the newest element leaves first and the oldest is buried underneath.

push() · pop() · top()

QUEUE

Two ends, one job each. Arrivals land at the rear, departures leave from the front, and the order in between is never touched.

enqueue() · dequeue() · front()

STACK — LAST IN, FIRST OUTLOOPING · ONE END DOES EVERYTHING

BOTTOMTOP · POP

102030

IN STACK · 310, 20 and 30 are stacked — 30 is on top.

QUEUE — FIRST IN, FIRST OUTLOOPING · TWO ENDS, TWO JOBS

FRONT · DEPARTUREARRIVAL · REAR

102030

IN LINE · 310, 20 and 30 are waiting — in the order they arrived.

READ IT AGAINSame stage, same arrivals — but the stack leaves from the top and the queue from the front. Everything else follows from that one difference.

Vocabulary

The Queue Blueprint

NAMEROLECOST

frontThe next element to leave the queue.int / Node*

rearThe last element to have arrived.int / Node*

enqueueAdd a value at the rear.O(1)

dequeueRemove the value at the front.O(1)

peekRead the front without removing it.O(1)

isEmptyIs there anything left to serve?O(1)

THE TWO ENDSREAR IS WHERE WORK ARRIVES · FRONT IS WHERE IT LEAVES

rear

[0]10

[1]20

[2]30

[3]—

[4]—

front

THE STATE RULESFOUR INVARIANTS

STATECONDITION

Emptyfront == rear == -1

Singlefront == rear

Fullrear == SIZE - 1

Wrappedrear + 1 == front

Array-Backed

Simple Queue (Array)

CAPACITYSIZE = 5 — the array is fixed at compile time.

ENQUEUErear++ then items[rear] = element

DEQUEUEfront++ — the value is left behind in the array.

STEP 1

First element: an empty queue has no front yet, so the first arrival takes cell 0.

if (front == -1) front = 0

STEP 2

Arrival: the rear walks forward with every element that joins the queue.

rear++

STEP 3

Departure: the front walks forward too — and it never walks back.

front++

FULL

The guard: once the rear reaches the last cell, the queue refuses new work.

rear == SIZE - 1

THE ARRAY — items[5]front → 0 · rear → 2

rear

[0]10

[1]20

[2]30

[3]—

[4]—

front

FIXED CAPACITYThe array never grows. The queue can hold five elements and not one more.

bool isFull() { return rear == SIZE - 1; }bool isEmpty() { return front == -1 || front > rear; }void enqueue(int element) { if (isFull()) { cout << "Queue is full!" << endl; return; } if (front == -1) front = 0; rear++; items[rear] = element;}void dequeue() { if (isEmpty()) { cout << "Queue is empty!" << endl; return; } cout << "Dequeued: " << items[front] << endl; front++;}void display() { if (isEmpty()) { cout << "Queue is empty!" << endl; return; } cout << "Queue elements: "; for (int i = front; i <= rear; i++) { cout << items[i] << " "; } cout << endl;}

The Problem

The Limitation

The front only ever moves forward. Every cell it leaves behind stays occupied for good — and the queue still calls itself full while those cells sit there, unused.

AFTER TWO DEQUEUESfront = 2 · rear = 2 · cells 0 and 1 are dead

THE GUARDisFull() asks only about rear — it never looks at front

Two more enqueues fill cells 3 and 4. Now the array is full, the queue holds three — and the two dead cells are out of reach for good.

DEAD SPACE

Two cells are lost: each dequeue frees a cell logically but leaves the value in memory. The queue can never reach them again.

front = 2, rear = 2

REFUSED

The queue turns work away while two cells sit empty at the head of the array — unusable, because the front never walks back.

Queue is full! Cannot enqueue 60

TWO CELLS LOST AT THE FRONTCELLS 0 AND 1 ARE UNREACHABLE

rear

[0]×

[1]×

[2]30

[3]40

[4]50

front

HATCHED CELLSCells 0 and 1 are spent — the values they held were consumed, and the memory was never handed back. The queue can never reach them again.

THE QUEUE REFUSES WORKrear == SIZE - 1

QUEUE HOLDS3 of 5 cells

The Fix

Circular Queue (Array)

THE FORMULArear = (rear + 1) % C_SIZE

WHY IT WORKSWhen the rear walks past the last cell, the modulo sends it back to cell 0.

The front wraps the same way: front = (front + 1) % C_SIZE.

EMPTY

Nothing queued: both pointers sit at -1 and the array is untouched.

front == rear == -1

WRAPPED

The rear is one step behind the front: the queue has wrapped around the array — and this shape is full too.

rear + 1 == front

FULL

Every cell in play: the queue is full only when no cell is left unused.

front == 0 && rear == C_SIZE - 1

WRAP

One operator: the increment that stopped at the end now wraps around.

rear = (rear + 1) % C_SIZE

THE SAME ARRAY, NOW A RINGTHE REAR WRAPS FROM CELL 4 TO CELL 0

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

NOTHING IS WASTEDCells 0 and 1 were freed by dequeue and have been used again. The array is full — but this time every cell still belongs to the queue.

bool isFull() { return (front == 0 && rear == C_SIZE - 1) || (rear + 1 == front);}void enqueue(int element) { if (isFull()) { cout << "Queue is full!" << endl; return; } if (isEmpty()) { front = rear = 0; } else { rear = (rear + 1) % C_SIZE; } // circular increment items[rear] = element;}void display() { if (isEmpty()) { cout << "Queue is empty!" << endl; return; } cout << "Queue elements: "; int i = front; while (true) { cout << items[i] << " "; if (i == rear) break; i = (i + 1) % C_SIZE; } cout << endl;}

Live Trace

The Wrap-Around

THE MOMENTrear = (4 + 1) % 5 = 0

THE RESULT60 is written into the very cell the first dequeue freed.

STEP 1

Drain the front: front walks to cell 2, and cells 0 and 1 become dead space.

dequeue() ×2

STEP 2

The rear leaves the end of the array and comes back to cell 0.

rear = (4 + 1) % 5

STEP 3

The dead cell becomes live again — 60 lands exactly where 10 used to be.

items[0] = 60

STEP 4

The queue is full once more, with five elements and no wasted cell.

front = 2, rear = 1

BEFORE — THE QUEUE IS FULLfront → 0 · rear → 4

rear

[0]10

[1]20

[2]30

[3]40

[4]50

front

AFTER — THE REAR WRAPPEDfront → 2 · rear → 1

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

READ THE ORDERWalking from front to rear and wrapping as it goes: 30, 40, 50, 60, 70. The array order and the queue order are different things.

Pointer-Based

Queue via Linked List

ENQUEUErear->next = newNode; rear = newNode

DEQUEUEfront = front->next; delete temp

No capacity limit and no dead space — the chain grows with the work and shrinks when it is served.

EMPTY

Nothing queued: both pointers are null, so the chain has no nodes at all.

rear == nullptr

ARRIVAL

Link forward: the old rear points at the new node — no element is ever copied.

rear->next = newNode

ARRIVAL

Advance the rear: the new node becomes the last element in the queue.

rear = newNode

DEPARTURE

Advance the front, then delete temp frees the node that left.

front = front->next

THE QUEUE IS A CHAINfront → 10 · rear → 30

front

data10next•

data20next•

rear

data30next•

nullptr

NO DEAD SPACEThe node that leaves is freed outright. The chain holds exactly the elements still waiting.

void enqueue(int value) { Node* newNode = new Node(value); if (rear == nullptr) { front = rear = newNode; } else { rear->next = newNode; rear = newNode; }}void dequeue() { Node* temp = front; front = front->next; if (front == nullptr) rear = nullptr; delete temp;}

The Ring

Circular Queue (Linked List)

In a circular linked list the last node points back at the first. The front of the queue is simply rear->next — so one pointer describes the whole structure.

THE FRONTrear->next

ARRIVALnewNode->next = rear->next; rear->next = newNode; rear = newNode

DEPARTURErear->next = temp->next; delete temp

The very first node points at itself. That is what makes the chain a ring.

FIRST

One node, pointing at itself: the empty queue becomes a one-element ring.

newNode->next = newNode

ARRIVAL

Link to the front: the new node is spliced in between the rear and the old front.

newNode->next = rear->next

LINK

Close the ring: the old rear now points at the new node, which becomes the rear.

rear->next = newNode

DEPARTURE

Bypass the front: the rear points past the departing node, and it is freed.

rear->next = temp->next

THE RING — THE LAST NODE POINTS BACKfront = rear->next

front

data10next•

data20next•

rear

data30next•

NO nullptrThere is no end marker in this chain. The ring simply closes, and rear->next is always the element that leaves next.

void enqueue(int value) { Node* newNode = new Node(value); if (isEmpty()) { newNode->next = newNode; // the first node points at itself rear = newNode; } else { newNode->next = rear->next; // the new node points at the front rear->next = newNode; // the old rear points at the new node rear = newNode; // the new node becomes the rear }}

Choosing

The Queue Family

ASPECTARRAYLINKED LIST

CapacityFixed at compile timeGrows with the work

Dead spaceOnly in the simple arrayNone

MemoryOne value per elementOne value plus a pointer

EnqueueO(1)O(1)

DequeueO(1)O(1)

Best whenThe size is bounded and knownThe size is unpredictable

VARIANTTHE TRADE-OFF

Simple (array)The simplest code there is — and it wastes the front of the array.

Circular (array)One modulo operator buys back every wasted cell.

Queue (linked list)Two pointers and a delete per departure.

Circular (list)One pointer instead of two — and no end marker to check.

SIMPLE QUEUE — THE LINEAR ARRAYTWO CELLS DEAD AT THE FRONT

rear

[0]×

[1]×

[2]30

[3]40

[4]50

front

CIRCULAR QUEUE — THE SAME ARRAY RINGEDNOTHING IS WASTED

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

SAME CONTRACTAll four honour enqueue, dequeue and peek identically. Only the storage and the price of memory differ.

Standard Library

The STL std::queue

APIpush · pop · front · back · empty · size

BACKING STOREA std::deque by default — a chain of fixed-size blocks.

The interface is the same FIFO contract you implemented by hand. Only the storage is somebody else's problem now.

ENQUEUE

Add at the rear. The name changed from enqueue to push, the position did not.

ticketLine.push("Alice")

DEQUEUE

Remove from the front. pop discards the element — read it with front first.

ticketLine.pop()

INSPECT

Look without removing: the first element and the last element are both one call away.

ticketLine.front() · .back()

#include <iostream>#include <queue>#include <string>using namespace std;int main() { queue<string> ticketLine; ticketLine.push("Alice"); ticketLine.push("Bob"); ticketLine.push("Charlie"); cout << "Current front of line: " << ticketLine.front() << endl; ticketLine.pop(); cout << "New front of line: " << ticketLine.front() << endl;}

CONSOLE OUTPUTEXIT CODE: 0

Current front of line: Alice
New front of line: Bob

NOTHING TO DELETEThere is no new and no delete in this program. The container owns its memory and frees it when it goes out of scope.

A Different Order

The STL std::priority_queue

APIpush · pop · top · empty · size

ORDERA max-heap by default — the largest element leaves first.

FLIP ITpriority_queue<int, vector<int>, greater<int>> makes it a min-heap.

CONTAINERWHEN TO USE IT

std::queueFIFO — the oldest task is served first. A ticket line, a print spool.

std::priority_queueBest-first — the most urgent task is served first. An incident queue.

The differenceBoth are queues to the caller. Only the order in which elements leave is different.

COSTOrdering by priority is not free: push and pop are O(log n), where a plain queue is O(1).

#include <iostream>#include <queue>using namespace std;int main() { priority_queue<int> tasks; tasks.push(2); // Priority 2 tasks.push(5); // Priority 5 (highest) tasks.push(1); // Priority 1 (lowest) tasks.push(4); // Priority 4 while (!tasks.empty()) { cout << tasks.top() << " "; tasks.pop(); }}

CONSOLE OUTPUTMAX-HEAP

5 4 2 1

WITH greater<int>MIN-HEAP

1 2 4 5

Defensive Logic

Critical Edge Cases

Every implementation needs the same guards: an empty queue, a queue that has just drained, a queue that is genuinely full, and a node that has already been freed.

CASEWHAT GOES WRONGGUARD

Empty QueueDequeuing from nothing returns garbage.if (isEmpty()) return;

Drained QueueThe front runs past the rear and the array is unusable.front = rear = -1;

Linear FullWork is refused while cells sit free at the front.rear == SIZE - 1

Circular FullTwo different states look full.rear + 1 == front

Freed NodeA deleted node is still linked into the chain.rear->next = temp->next

Empty HeapReading top() on an empty priority queue is undefined.if (!tasks.empty())

EMPTY — NO FRONT, NO REARfront == rear == -1

rear

[0]—

[1]—

[2]—

[3]—

[4]—

front

CIRCULAR FULL — EVERY CELL STILL IN PLAYrear + 1 == front

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

THE DIFFERENCEA linear queue is full with three of five cells in use. A circular queue is only full when all five belong to the queue.

Master Reference

Complexity Reference

OPERATIONARRAY QUEUELINKED LIST

enqueueO(1)O(1)

dequeueO(1)O(1)

peekO(1)O(1)

displayO(n)O(n)

isEmptyO(1)O(1)

MemoryO(1) — fixedO(n) — dynamic

IMPLEMENTATIONTHE PRICE

Simple queueO(1) operations, fixed capacity, wastes the front of the array.

Circular queueO(1) operations, fixed capacity, and no wasted cell.

Linked-list queueO(1) operations, dynamic growth, one pointer of overhead per element.

Circular list queueO(1) operations, dynamic growth, one pointer for the whole queue.

std::queueO(1) operations, dynamic growth, and none of the bookkeeping.

std::priority_queueO(log n) push and pop, O(1) top — the cost of ordering by priority.

THE SHAPEEvery FIFO queue here is O(1) at both ends — only the priority queue pays O(log n) to keep its order. The real differences are capacity, memory and correctness.

End-to-End Program Trace

Complete Walkthrough

THE CIRCULAR QUEUE — STATE AFTER EVERY CALL13 CALLS · FINAL: 30 40 50 60 70

Call	Queue after	Output printed
enqueue(10)	10	Enqueued: 10
enqueue(20)	10 20	Enqueued: 20
enqueue(30)	10 20 30	Enqueued: 30
enqueue(40)	10 20 30 40	Enqueued: 40
enqueue(50)	10 20 30 40 50	Enqueued: 50
display()	10 20 30 40 50	Queue elements: 10 20 30 40 50
dequeue()	20 30 40 50	Dequeued: 10
dequeue()	30 40 50	Dequeued: 20
display()	30 40 50	Queue elements: 30 40 50
enqueue(60)	30 40 50 60	Enqueued: 60
enqueue(70)	30 40 50 60 70	Enqueued: 70
display()	30 40 50 60 70	Queue elements: 30 40 50 60 70
peek()	unchanged	Front element: 30

ACTUAL PROGRAM OUTPUTEXIT CODE: 0

=== Fill the Queue ===
Enqueued: 10
Enqueued: 20
Enqueued: 30
Enqueued: 40
Enqueued: 50
Queue elements: 10 20 30 40 50

=== Dequeue Twice ===
Dequeued: 10
Dequeued: 20
Queue elements: 30 40 50

=== Wrap-Around ===
Enqueued: 60
Enqueued: 70
Queue elements: 30 40 50 60 70

=== Peek ===
Front element: 30

FINAL STATE OF THE ARRAYfront → 2 · rear → 1

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

Classroom Check

Predict the Output

Trace the four calls by hand before revealing the answer. Use only the rules already covered — especially what the modulo does at the end of the array.

STARTING QUEUE — FULLfront → 0 · rear → 4

rear

[0]10

[1]20

[2]30

[3]40

[4]50

front

// Starting queue: 10 20 30 40 50 (full)cq.dequeue();cq.dequeue();cq.enqueue(60);cq.enqueue(70);

ANSWER HIDDEN

STEPWHAT THE CALL DOESQUEUE AFTER

1Two dequeues walk the front to cell 230 40 50

2enqueue(60) wraps the rear to cell 030 40 50 60

3enqueue(70) advances the rear to cell 130 40 50 60 70

ANSWER — REVEAL AFTER THE DISCUSSIONFRONT → 2 · REAR → 1

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

EXPECTED display() OUTPUTVERIFIED

Queue elements: 30 40 50 60 70

Lesson Synthesis

Key Takeaways

PRINCIPLEREMEMBER

FIFOArrivals join at the rear; departures leave from the front.

Two endsA queue inserts and removes at opposite ends — a stack does both at one.

Dead spaceA linear array queue never reuses the cells its front leaves behind.

The modulo(rear + 1) % C_SIZE turns the array into a ring.

The ringIn a circular list the front is simply rear->next.

The STLstd::queue for FIFO, std::priority_queue for best-first.

The costEvery queue here is O(1) at both ends — except the priority queue.

ONE LAST LOOK AT THE RING30 → 40 → 50 → 60 → 70

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

REACH FORWHEN

Simple queueThe size is known, bounded, and the waste does not matter.

Circular queueThe size is known, bounded, and every cell has to earn its keep.

Linked-list queueThe size is unpredictable and the memory is not.

std::queueAlmost always — unless you need the ordering the STL cannot give you.

Download all sources (.zip) — 6 files

NEXTSection 04 moves on to trees — the first structure where nodes branch instead of chaining.