Queue

If a stack is a pile of plates, a queue is a line of people at the school canteen. The first person to join the line is the first one served; newcomers join at the back. Nobody pushes in. That single rule — first in, first out (FIFO) — is what makes a queue different from a stack.

A queue keeps two pointers: front (who's next to be served) and rear (where the last person stood). You add at the rear and remove from the front.

Imagine a queue stored in a list of 5 slots. You enqueue A, B, C, D, E (rear reaches index 4), then dequeue A and B (front moves to index 2). Indexes 0 and 1 are now free, but a plain "linear" queue cannot use them: the rear pointer is already at the end. The queue looks full even though two slots are empty. That is wasted space.

# Circular wrap with MOD
rear = (rear + 1) % MAX_SIZE   # enqueue: wrap rear
front = (front + 1) % MAX_SIZE # dequeue: wrap front

# Example: rear = 4, MAX_SIZE = 5
# (4 + 1) % 5 = 5 % 5 = 0  -> rear wraps to index 0

# Example: front = 7, MAX_SIZE = 8
# (7 + 1) % 8 = 8 % 8 = 0  -> front wraps to index 0

Try the circular queue yourself. Set MAX_SIZE, enter a value, and click Enqueue or Dequeue. Watch the front (cyan) and rear (amber) pointers move and wrap around. Try to trigger overflow and underflow.

1MAX_SIZE = 5; queue = [None]*MAX_SIZE
2if count == MAX_SIZE:
3    return False  # overflow
4    rear = (rear + 1) % MAX_SIZE
5    queue[rear] = item; count += 1
6if count == 0:
7    return None  # underflow
8    item = queue[front]
9    front = (front + 1) % MAX_SIZE
10    count -= 1; return item

enqueue() adds a new item at the rear of the queue. The order is: check full → move rear with MOD → store item → increment count.

MAX_SIZE = 5
queue = [None] * MAX_SIZE
front = 0          # index of the next item to remove
rear = -1          # index of the last item added
count = 0          # how many items are stored

def enqueue(item):
    global rear, count
    if count == MAX_SIZE:           # is the queue full?
        print("Queue overflow")
    else:
        rear = (rear + 1) % MAX_SIZE    # move rear, wrap if needed
        queue[rear] = item              # store the item
        count = count + 1              # one more item now

dequeue() removes and returns the front item. The order is: check empty → read item → move front with MOD → decrement count → return item.

def dequeue():
    global front, count
    if count == 0:                    # is the queue empty?
        return None
    else:
        item = queue[front]             # read the front item
        front = (front + 1) % MAX_SIZE  # move front, wrap if needed
        count = count - 1              # one fewer item now
        return item                     # give it back to the caller

def is_empty():
    return count == 0

def is_full():
    return count == MAX_SIZE

def peek():
    if is_empty():
        return None
    return queue[front]     # front item, not removed

def spaces_left():
    return MAX_SIZE - count

A trace shows front, rear, and count after each operation. Remember: rear wraps with (rear + 1) % MAX_SIZE.

# MAX_SIZE = 4, start empty (front=0, rear=-1, count=0)

start      front=0 rear=-1 count=0
enqueue X  front=0 rear=0  count=1
enqueue Y  front=0 rear=1  count=2
dequeue    front=1 rear=1  count=1  (X out)
enqueue Z  front=1 rear=2  count=2

Tarnima runs an online helpdesk. Support tickets must be answered in the order they arrive. She stores up to 6 tickets in a circular queue.

Fifteen exam-style queue tasks. Each shows only the question — click Hint for the thought process, or Help for the worked solution.