Introduction

Learning Outcomes

The Queue ADT

The Queue

• A linear data structure that is open at both ends.
• Items leave in the order they arrived: first in, first out (FIFO).
• Items join at one end (the rear) and leave from the other (the front).
• Think of the line at a checkout or a ticket window: whoever arrives first is served first.

The Queue ADT

Basic Queue Operations

Horses walking single file: the one in front passes first, and newcomers join at the back.

The Queue ADT

The Queue Abstract Data Type

public interface Queue<E> {
    int size();
    boolean isEmpty();
    void enqueue(E e);
    E first();    // null if empty
    E dequeue();  // null if empty
}

The Queue ADT

Queue Operations, Step by Step

The Queue ADT

Queues in Java: java.util.Queue

Queue<Integer> q = new ArrayDeque<>();
q.offer(20);
q.offer(10);
q.offer(15);        // [20, 10, 15]
q.peek();           // 20, not removed
q.poll();           // 20 → [10, 15]
q.poll();           // 10 → [15]
q.size();           // 1
q.poll();           // 15 → []
q.poll();           // null (empty)

The Queue ADT

Where Queues Are Used

Array-Based Queues

A Queue in an Array

• The items live in an array, and two indices mark the ends of the queue:
  • front: index of the first item.
  • rear: index of the last item.
• Enqueue increments rear; dequeue increments front. Items never move.
• Simple and fast, but the array has a fixed capacity.

The item at index 0 was dequeued earlier. Its slot is free now, but a simple array queue cannot reuse it.

Array-Based Queues

The Trouble with a Simple Array Queue

Array-Based Queues

The Circular Queue

Here rear is the free slot where the next item will go: rear = (front + size) % N = (0 + 5) % 8 = 5.

Array-Based Queues

Moving the Indices with Mod

Array-Based Queues

Full or Empty?

With only the front and rear indices, an empty and a full queue look the same: both indices point to the same slot. Two common fixes:

Array-Based Queues

Circular Queue, Step by Step (N = 5)

Array-Based Queues

Circular Queue: Class and Status Queries

public class CircularQueue<E> {
    private E[] data;       // stores the items
    private int front = 0;    // index of the first item
    private int size = 0;  // number of items

    @SuppressWarnings("unchecked")
    public CircularQueue(int capacity) {
        data = (E[]) new Object[capacity];
    }
    public int size()      { return size; }
    public boolean isEmpty()  { return size == 0; }
    public boolean isFull() { return size == data.length; }
    public E first()          { return isEmpty() ? null : data[front]; }
    // enqueue(), dequeue()
}

Array-Based Queues

Circular Queue: enqueue and dequeue

public void enqueue(E item) {           // enqueue
    if (isFull())
        throw new IllegalStateException("full");
    int avail = (front + size) % data.length;
    data[avail] = item;
    size++;
}

public E dequeue() {                  // dequeue
    if (isEmpty())
        throw new IllegalStateException("empty");
    E item = data[front];
    data[front] = null;               // drop the reference
    front = (front + 1) % data.length;
    size--;
    return item;
}

Linked Queues

A Queue in a Linked List

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
    }
}
// fields:
Node front, rear;
int size;

Why insert at the tail and remove at the head? In a singly linked list, removing the head is O(1), but removing the tail means finding its predecessor: O(n).

Linked Queues

Enqueue and Dequeue Algorithms

Linked Queues · Step through the code

Code Trace: Linked Queue enqueue

public void enqueue(int data) {
    Node temp = new Node(data);
    if (isEmpty()) {
        front = temp;
    } else {
        rear.next = temp;
    }
    rear = temp;
    size++;
}

Linked Queues · Step through the code

Code Trace: Linked Queue dequeue

public int dequeue() {
    if (isEmpty())
        throw new NoSuchElementException();
    int result = front.data;
    front = front.next;
    if (front == null)
        rear = null;
    size--;
    return result;
}

Linked Queues

Circular Array or Linked List?

Kinds of Queues

Kinds of Queues

Kinds of Queues

The Double-Ended Queue (Deque)

Kinds of Queues

Deque Operations, Step by Step

Kinds of Queues

Deque: Inserting at Either End

public void addFirst(E data) {
    Node<E> node = new Node<>(data);
    if (isEmpty()) {
        head = tail = node;
    } else {
        node.next = head;
        head.prev = node;
        head = node;
    }
    size++;
}

public void addLast(E data) {
    Node<E> node = new Node<>(data);
    if (isEmpty()) {
        head = tail = node;
    } else {
        node.prev = tail;
        tail.next = node;
        tail = node;
    }
    size++;
}

class Node<E> {
    E data;
    Node<E> prev, next;
    Node(E data) { this.data = data; }
}

The two methods mirror each other: head ↔ tail, prev ↔ next.

Kinds of Queues · Step through the code

Code Trace: Deque addFirst()

public void addFirst(E data) {
    Node<E> node = new Node<>(data);
    if (isEmpty()) {
        head = tail = node;
    } else {
        node.next = head;
        head.prev = node;
        head = node;
    }
    size++;
}

Kinds of Queues

Deque: Removing from Either End

public E removeFirst() {
    if (isEmpty()) return null;
    E data = head.data;
    head = head.next;
    if (head == null)
        tail = null;       // now empty
    else
        head.prev = null;
    size--;
    return data;
}

public E removeLast() {
    if (isEmpty()) return null;
    E data = tail.data;
    tail = tail.prev;
    if (tail == null)
        head = null;       // now empty
    else
        tail.next = null;
    size--;
    return data;
}

Kinds of Queues · Step through the code

Code Trace: Deque removeLast()

public E removeLast() {
    if (isEmpty()) return null;
    E data = tail.data;
    tail = tail.prev;
    if (tail == null)
        head = null;       // now empty
    else
        tail.next = null;
    size--;
    return data;
}

Applications

Application: A Round-Robin Scheduler

The operating system gives the CPU to processes in turn: the process at the front runs for at most q time units and, if unfinished, rejoins at the rear.

Simulator: Round-Robin Scheduler (adjustable quantum and processes).

Applications

Example: Binary Numbers from 1 to n

Applications · Step through the code

Code Trace: generateBinary(4)