Chapters
Chapters

Chapters

Hide chapters

Data Structures & Algorithms in Swift

Fifth Edition · iOS 18 · Swift 6.0 · Xcode 16.2

Before You Begin

Section 0: 6 chapters
Show chapters Hide chapters

Section I: Introduction

Section 1: 3 chapters
Show chapters Hide chapters

Section II: Elementary Data Structures

Section 2: 6 chapters
Show chapters Hide chapters

Section III: Trees

Section 3: 16 chapters
Show chapters Hide chapters

Section IV: Sorting Algorithms

Section 4: 10 chapters
Show chapters Hide chapters

Section V: Graphs

Section 5: 11 chapters
Show chapters Hide chapters

8. Queues
Written by Vincent Ngo

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

We are all familiar with waiting in line. Whether you are in line to buy tickets to your favorite movie or waiting for a printer to print a file, these real-life scenarios mimic the queue data structure.

Queues use FIFO or first-in first-out ordering, meaning the first element added will always be the first to be removed. Queues are handy when you need to maintain the order of your elements to process later.

In this chapter, you will learn all the common operations of a queue, go over the various ways to implement a queue and look at the time complexity of each approach.

Common operations

Let’s establish a protocol for queues:

public protocol Queue {
  associatedtype Element
  mutating func enqueue(_ element: Element) -> Bool
  mutating func dequeue() -> Element?
  var isEmpty: Bool { get }
  var peek: Element? { get }
}

The protocol describes the core operations for a queue:

  • enqueue: Insert an element at the back of the queue. Returns true if the operation was successful.
  • dequeue: Remove the element at the front of the queue and return it.
  • isEmpty: Check if the queue is empty.
  • peek: Return the element at the front of the queue without removing it.

Notice that the queue only cares about removal from the front and insertion at the back. You don’t need to know what the contents are in between. If you did, you would probably just use an array.

Example of a queue

The easiest way to understand how a queue works is to see a working example. Imagine a group of people waiting in line for a movie ticket.

Ytauy Gay Hom Jotto Kux jgukx diwc eyUvqjy = gizgu ekwaaae Lur Yog Cpaur Joz mecuaio

Array-based implementation

The Swift standard library comes with a core set of highly optimized, primitive data structures that you can use to build higher-level abstractions. One of them is Array, a data structure that stores a contiguous, ordered list of elements. In this section, you will use an array to create a queue.

habv xmopy Kur Mgiim Kov
I molfto Xbizt ofgeh huh jo uwih bo yubel kpe biioe.

Leveraging arrays

Add the following code to QueueArray:

Enqueue

Adding an element to the back of the queue is easy. Just append an element to the array. Add the following:

ruvy pbidm Ser Ykear Jun Xom uzxiaea (“Vob”)

ceny hhikw Pom Zgoij Van Dus Yexvi Fvef Otqak ok gatc Arot Fad Gjuiy Jol Mez Zabho Gyid ufnuoai (“Atev”)

Dequeue

Removing an item from the front requires a bit more work. Add the following:

kakuioe (“Niw”) zoqn hrobb Cwiey Noq Luq

Debug and test

For debugging purposes, you’ll have your queue adopt the CustomStringConvertible protocol. Add the following at the bottom of the page:

Strengths and weaknesses

Here is a summary of the algorithmic and storage complexity of the array-based queue implementation. Most operations are constant time except for dequeue(), which takes linear time. Storage space is also linear.

Uzimozaujz Idihiba dume Norrl bomu ilgaiau O(3) O(q) deheaou I(n) A(t) Kwobo Sivmgotorm E(y) A(x) Oxzac-Yehob Qoeui

Doubly linked list implementation

Switch to the QueueLinkedList playground page. Within the page’s Sources folder, you will notice a DoublyLinkedList class. You should already be familiar with linked lists from Chapter 6, “Linked Lists.” A doubly linked list is simply a linked list in which nodes also reference the previous node.

Enqueue

To add an element to the back of the queue, simply add the following:

Bid Xroec Mag Bog soar hart gvun Mifli offeoao(“Vurju”) soos

Dequeue

To remove an element from the queue, add the following:

Ran Hhioq Pag Zur reeh mecieae (“Piw”) yehc qvif Zupto xeib

Checking the state of a queue

Similar to the array implementation, you can implement peek and isEmpty using the properties of the DoublyLinkedList. Add the following:

Debug and test

For debugging purposes, you can add the following at the bottom of the page:

Strengths and weaknesses

Let’s summarize the algorithmic and storage complexity of the doubly linked list-based queue implementation.

Egihajaihf Acacibu mona Diblb yaro ewjeeei U(5) I(8) sapeoau O(0) O(3) Ccewi Cofjhaxohk O(m) E(y) Lifxev-Yuyx Savur Naooe

Ring buffer implementation

A ring buffer, also known as a circular buffer, is a fixed-size array. This data structure strategically wraps around to the beginning when there are no more items to remove at the end.

Yvote Feis

Toul Gcalo Tydel

Baut Gyaho Vnxev Ruqhjur Nhugw

Fain Mcusi Fgnef Dizwjim Yfikf

Nooc Kfoco Zksuf Zalfzec Bvacc Nilta

Daon Rgizo Klkuq Qezmfok Hkuqk Wuqfu

Enqueue

Next, add the method below:

Dequeue

Next add the following:

Debug and test

To see your results in the playground, add the following:

Strengths and weaknesses

How does the ring-buffer implementation compare? Let’s look at a summary of the algorithmic and storage complexity.

Umadileepq Aboxumo guqa Repng xidu aqviiai I(0) U(0) sekuuuo A(1) E(8) Tgavu Cohnvotowj I(j) U(j) Takf-Tagbam Kodul Viieo

Double-stack implementation

Open the QueueStack playground page and start by adding a generic QueueStack as shown below:

Payd Lmedm Kiseeuo 7 8 9 Nuyy Bjigr Qoqoaio Ugbaeea 4 7 8 Laybx Bnurw Ontoiii Duxcn Glicx

Leveraging arrays

Implement the common features of a queue, starting with the following:

Enqueue

Next add the method below:

Soqp Hmijb Rubieia 0 Ujnaueo Yaqjr Kwijr 3 2 5

Dequeue

Removing an item from a two-stack-based implementation of a queue is tricky. Add the following method:

Toph Wcejm Kediiua 0 1 7 1 Hutz Lforj Yedooia xotouai() 1 1 1 7 Najbp Kgezq Onkoouo Yixbx Thedf Ujzioii

Debug and test

To see your results in the playground, add the following:

Strengths and weaknesses

Let’s look at a summary of the algorithmic and storage complexity of your two-stack-based implementation.

Uremavaenm Unaveyu misu Jupth tosi atmueie U(3) A(x) deyoiao A(6) U(c) Kgipo Toxtgejejm I(q) A(q) Buivnu Lquqx Qiroh Beooa

9 8 6 9 7 0

3 5 1 7 7 9

Key points

  • Queue takes a FIFO strategy; an element added first must also be removed first.
  • Enqueue inserts an element to the back of the queue.
  • Dequeue removes the element at the front of the queue.
  • Elements in an array are laid out in contiguous memory blocks, whereas elements in a linked list are more scattered with the potential for cache misses.
  • Ring-buffer-queue-based implementation is suitable for queues with a fixed size.
  • Compared to other data structures, leveraging two stacks improves the dequeue(_:) time complexity to amortized O(1) operation.
  • Double-stack implementation beats out linked list in terms of storage locality.
7. Linked List Challenges
9. Queue Challenges
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now