Grokking algorithms: an illustrated guide for programmers and other curious people

Table of contents

Machine generated contents note: Introduction
What you'll learn about performance
What you'll learn about solving problems
Binary search
A better way to search
Running time
Big O notation
Algorithm running times grow at different rates
Visualizing different Big O run times
Big O establishes a worst-case run time
Some common Big O run times
The traveling salesperson
Recap
How memory works
Arrays and linked lists
Linked lists
Arrays
Terminology
Inserting into the middle of a list
Deletions
Selection sort
Recursion
Base case and recursive case
The stack
The call stack
The call stack with recursion
Divide & conquer
Quicksort
Big O notation revisited
Merge sort vs. quicksort
Average case vs. worst case
Hash functions
Use cases
Using hash tables for lookups
Preventing duplicate entries
Using hash tables as a cache
Collisions
Performance
Contents note continued: Load factor
A good hash function
Introduction to graphs
What is a graph?
Breadth-first search
Finding the shortest path
Queues
Implementing the graph
Implementing the algorithm
Working with Dijkstra's algorithm Q
Trading for a piano
Negative-weight edges
Implementation
The classroom scheduling problem
The knapsack problem
The set-covering problem
Approximation algorithms
NP-complete problems
Traveling salesperson, step by step
How do you tell if a problem is NP-complete?
The simple solution
Dynamic programming
Knapsack problem FAQ
What happens if you add an item?
What happens if you change the order of the rows?
Can you fill in the grid column-wise instead of row-wise?
What happens if you add a smaller item?
Can you steal fractions of an item?
Optimizing your travel itinerary
Contents note continued: Handling items that depend on each other
Is it possible that the solution will require more than two sub-knapsacks?
Is it possible that the best solution doesn't fill the knapsack completely?
Longest common substring
Making the grid
Filling in the grid
The solution
Longest common subsequence
Longest common subsequence-solution
Classifying oranges vs. grapefruit
Building a recommendations system
Feature extraction
Regression
Picking good features
Introduction to machine learning
OCR
Building a Spam filter
Predicting the stock market
Trees
Inverted indexes
The Fourier transform
Parallel algorithms
MapReduce
Why are distributed algorithms useful?
The map function
The reduce function
Bloom filters and HyperLogLog
Bloom filters
HyperLogLog
The SHA algorithms
Comparing files
Checking passwords
Locality-sensitive hashing
Contents note continued: Diffie-Hellman key exchange
Linear programming
Epilogue

Grokking Algorithms is a fully illustrated, friendly guide that teaches you how to apply common algorithms to the practical problems you face every day as a programmer. You'll start with sorting and searching and, as you build up your skills in thinking algorithmically, you'll tackle more complex concerns such as data compression and artificial intelligence. Each carefully presented example includes helpful diagrams and fully annotated code samples in Python.

Learning about algorithms doesn't have to be boring! Get a sneak peek at the fun, illustrated, and friendly examples you'll find in Grokking Algorithms on YouTube.

If you want to get more from the classic algorithms inside this book then be sure to check out Algorithms in Motion. Together this book and video course make the perfect duo.

https://www.manning.com/books/grokking-algorithms