Learn

Data Structures and Algorithms

The core structures and the patterns that solve most problems.

Understand, from the ground up, how computers solve problems efficiently. The core data structures and the handful of patterns behind most problems, with the time and space cost of each in Big-O, so I can pick the right structure and hand-trace why it works without looking it up.

Written by Claude Opus 4.8 25 lessons, 9 modules updated Jul 2026

Module 0 Foundations

start here

What is an algorithm?

A precise recipe, and what makes one good

Big-O notation

Measuring cost by how it grows, not by seconds

Module 1 Linear Structures

data in a row

Arrays and memory

Contiguous cells and why index access is instant

Binary search

Halving the haystack every step

Linked lists

Nodes and pointers: cheap inserts, slow lookups

Stacks, queues, and deques

Order of removal is the whole idea

Module 2 Recursion and Hashing

two big ideas

Recursion and the call stack

A function that calls itself, and where it lives

Hashing and hash tables

Turning a key into an address for instant lookup

Module 3 Sorting

order from chaos

Sorting

From quadratic swaps to n log n divide and conquer

Module 4 Trees and Graphs

structure with branches

Trees and binary search trees

Branching structure and ordered lookup

Heaps and priority queues

Always reach the smallest thing fast

Graphs, BFS, and DFS

Nodes, edges, and the two ways to explore them

Module 5 Algorithmic Patterns

the strategies

Two pointers and sliding window

Scanning from both ends and maintaining a window

Divide and conquer

Split the problem, solve the halves, merge

Dynamic programming

Overlapping subproblems and optimal substructure

Backtracking

Build candidates incrementally, prune on failure

Greedy algorithms

Always pick the locally optimal choice

Bit manipulation

Operating on the binary representation directly

Module 6 Advanced Structures

deeper tools

Tries (prefix trees)

Character-by-character lookup for strings

Self-balancing trees

AVL and red-black: guaranteed log-time ops

Strings and pattern matching

KMP, Rabin-Karp, and the suffix machinery

Union-Find (disjoint set)

Track connected components in near-constant time

Module 7 Graph Algorithms

weighted paths and spanning

Shortest paths: Dijkstra

The priority-queue BFS for weighted edges

Topological sort, MST, and Bellman-Ford

Ordering, spanning, and negative weights

Module 8 Complexity Theory

the limits of computation

Complexity classes and P vs NP

Which problems are tractable, and the biggest open question

Reference shelf

Glossary

Every load-bearing term from the 25 lessons, crisply defined.

Big-O cheat sheet

Every structure and algorithm, average and worst case, plus space.

Patterns

Read the problem's signature, reach for the right technique.

How to use this course

Do the widgets. The quizzes and flashcards are not decoration: trying to recall before you reveal is what makes it stick.
Space it out. Come back a day later and answer them cold.
Read critically. An LLM wrote these, so verify anything before you rely on it.