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

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