Data Structures & Algorithms in Swift: Implementing practical data structures with Swift 4.2

✍ Scribed by raywenderlich Tutorial Team, Kelvin Lau, Vincent Ngo

• Publisher: Razeware LLC
• Year: 2019
• Tongue: English
• Leaves: 430
• Category: Library

✦ Synopsis

Learn Data Structures & Algorithms in Swift!

Data structures and algorithms form the basis of computer programming and are the starting point for anyone looking to become a software engineer. Choosing the right data structure and algorithm involves understanding the many details and trade-offs of using them, which can be time-consuming to learn — and confusing.

This is where this book, Data Structures & Algorithms in Swift, comes to the rescue! In this book, you’ll learn the nuts and bolts of how fundamental data structures and algorithms work by using easy-to-follow tutorials, loaded with illustrations; you'll also learn by working in Swift playground code.

Who This Book Is For

This book is for developers who know the basics of Swift syntax and want a better theoretical understanding of what data structures and algorithms are in order to build more complex programs or ace a whiteboard interview.

Topics Covered in Data Structures & Algorithms in Swift

Basic data structures and algorithm including stacks, queues and linked lists.

How protocols can be used to generalize algorithms.

How to leverage the algorithms of the Swift standard library with your own data structures.

Trees, tries and graphs.

Building algorithms on top of other primitives.

A complete spectrum of sorting algorithms from simple to advanced.

How to think about algorithmic complexity.

Finding shortest paths, traversals, subgraphs and much more.

After reading this book, you’ll have a solid foundation on data structures and algorithms and be ready to elegantly solve more complex problems in your apps.

✦ Table of Contents

Book License
Who This Book Is For
What You Need
Book Source Code & Forums
About the Cover
Foreword
Chapter 1: Why Learn Data Structures & Algorithms?
The goal of this book
Chapter 2: Complexity
Time complexity
Space complexity
Other notations
Playground line-based execution bug
Key points
Chapter 3: Swift Standard Library
Array
Dictionary
Set
Key points
Chapter 4: Stack Data Structure
Stack operations
Implementation
push and pop operations
Key points
Chapter 5: Stack Challenges
Solutions
Chapter 6: Linked List
Node
LinkedList
Adding values to the list
Removing values from the list
Swift collection protocols
Becoming a Swift collection
Value semantics and copy-on-write
Optimizing COW
Key points
Chapter 7: Linked List Challenges
Solutions
Chapter 8: Queues
Common operations
Example of a queue
Array-based implementation
Doubly linked list implementation
Ring buffer implementation
Double-stack implementation
Key points
Chapter 9: Queue Challenges
Solutions
Chapter 10: Trees
Terminology
Implementation
Traversal algorithms
Key points
Chapter 11: Tree Challenges
Solutions
Chapter 12: Binary Trees
Implementation
Traversal algorithms
Key points
Chapter 13: Binary Tree Challenges
Solutions
Chapter 14: Binary Search Trees
Case study: array vs. BST
Implementation
Key points
Chapter 15: Binary Search Tree Challenges
Solutions
Chapter 16: AVL Trees
Understanding balance
Implementation
Key points
Where to go from here?
Chapter 17: AVL Tree Challenges
Solutions
Chapter 18: Tries
Example
Implementation
Key points
Chapter 19: Trie Challenges
Solutions
Chapter 20: Binary Search
Example
Implementation
Key points
Chapter 21: Binary Search Challenges
Solutions
Chapter 22: The Heap Data Structure
What is a heap?
The heap property
Heap applications
Common heap operations
How do you represent a heap?
Removing from a heap
Inserting into a heap
Removing from an arbitrary index
Searching for an element in a heap
Building a heap
Testing
Key points
Chapter 23: Heap Data Structure Challenges
Solutions
Chapter 24: Priority Queue
Applications
Common operations
Implementation
Testing
Key points
Chapter 25: Priority Queue Challenges
Solutions
Chapter 26: O(n²) Sorting Algorithms
Bubble sort
Selection sort
Insertion sort
Generalization
Key points
Chapter 27: O(n²) Sorting Challenges
Solutions
Chapter 28: Merge Sort
Example
Implementation
Performance
Key points
Chapter 29: Merge Sort Challenges
Solutions
Chapter 30: Radix Sort
Example
Implementation
Key points
Chapter 31: Radix Sort Challenges
Solution to Challenge 1
Chapter 32: Heap Sort
Getting started
Example
Implementation
Performance
Key points
Chapter 33: Heap Sort Challenges
Solutions
Chapter 34: Quicksort
Example
Partitioning strategies
Effects of a bad pivot choice
Key points
Chapter 35: Quicksort Challenges
Solutions
Chapter 36: Graphs
Weighted graphs
Common operations
Defining a vertex
Defining an edge
Adjacency list
Implementation
Adjacency matrix
Implementation
Graph analysis
Key points
Chapter 37: Graphs Challenges
Solutions
Chapter 38: Breadth-First Search
Example
Implementation
Performance
Key points
Chapter 39: Breadth-First Search Challenges
Solutions
Chapter 40: Depth-First Search
Example
Implementation
Performance
Key points
Chapter 41: Depth-First Search Challenges
Solutions
Chapter 42: Dijkstra’s Algorithm
Example
Implementation
Trying out your code
Performance
Key points
Chapter 43: Dijkstra’s Algorithm Challenges
Solutions
Chapter 44: Prim’s Algorithm
Example
Implementation
Testing your code
Performance
Key points
Chapter 45: Prim’s Algorithm Challenges
Solutions
Conclusion