Free through lesson 3

Algorithms for Beginners

From reading Big-O notation and measuring complexity for real, through arrays, search, sorting, stacks, queues, hash tables, trees, heaps, graph traversal, dynamic programming, greedy algorithms and string algorithms, to how to approach a problem at all. Twenty lessons that take you to the point where you can look at your own code and say why it is slow. No third-party libraries. Every piece of code and result shown was produced by actually running Python 3.14.2.

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are grouped into seven chapters. Chapter 1 (lessons 1 and 2) is the heart of the course; every lesson after it uses the measuring tools you build there, so starting from lesson 1 is the best way. Note: this is not a competitive programming course. It is written about making real production code faster. Note: the samples run inside the browser (no third-party libraries). For the larger measurements, use your own python3.

Chapter 1 — Foundations (lessons 1–2)

The two lessons at the heart of this course. How to look at complexity in Big-O terms, and how to measure it yourself. You come away with one tool: double n and watch how the time grows.

1

Algorithms and complexity (reading Big-O)

Solving the same problem by linear and binary search, and seeing a 14,243x difference at a million records. Big-O is a notation for the growth rate and nothing else.

Free
2

Measuring complexity for real (perf_counter and the median)

Double n and see how many times longer it takes. Good measurement practice, and the constant factor that varies 18x within the same O(n).

Free

Chapter 2 — Arrays and search (lessons 3–5)

You get clear on how a Python list is laid out internally, then write linear and binary search. You also pick up the judgement of choosing a method based on how many times you will search.

3

Arrays and lists (595x between pop() and pop(0))

A Python list is a contiguous row of boxes. The end is O(1), the front is O(n). When to use a deque instead, and amortised complexity.

Free
4

Linear search (choose by how many times you will search)

There are cases where linear search beats binary search. The gap against the built-in in and index, and how many searches it takes to pay off sorting.

🔒 Basic
5

Binary search (running the three failures for real)

An infinite loop, missing the last element, and a wrong answer on unsorted data. How to use bisect, and the pattern of binary searching over the answer.

🔒 Basic

Chapter 3 — Sorting (lessons 6–9)

Three hand-written O(n^2) sorts, merge sort, quicksort, and the built-in Timsort. Between them, every axis of comparison comes out: worst case, stability and the constant factor.

6

Sorting 1: bubble, selection and insertion

Three hand-written O(n^2) sorts. Insertion sort is strong on nearly sorted data, and selection sort is the only unstable one.

🔒 Basic
7

Sorting 2: merge sort and divide and conquer

The log in O(n log n) is the number of times you halve it. The merge is the real work, and one character decides stability.

🔒 Basic
8

Sorting 3: quicksort and the worst case

Run the naive implementation on already-sorted data and it becomes O(n^2), stopping with a RecursionError at n=1,000.

🔒 Basic
9

The built-in sort and key (Timsort is 42x faster)

The difference between sorted and .sort, key and tuples, how to use a stable sort, and how Timsort spots data that is already in order.

🔒 Basic

Chapter 4 — Data structures (lessons 10–14)

Stacks, queues, linked lists, hash tables, trees and heaps. The single most effective change in real code — turning an in over a list into a set (1,058x) — is here.

10

Stacks and queues (one line turns BFS into DFS)

The only difference is which end you take from. Bracket matching, undo and maze solving all run on the same code.

🔒 Basic
11

Linked lists (the exact opposite properties to an array)

There is almost no reason to write one yourself in Python. And yet it is doing the work inside deque, hash tables and LRU caches.

🔒 Basic
12

Hash tables (1,000x by turning an in into a set)

Why dict and set are O(1). Collisions and hash functions, and 1,058x on Two Sum. The single most effective lesson for real code.

🔒 Basic
13

Trees and binary search trees (the shape depends on the insertion order)

Folders, the DOM and JSON are all trees. A binary search tree degenerates into a linked list depending on the insertion order. Four ways to traverse one.

🔒 Basic
14

Heaps and priority queues (the top ten, 21x faster)

You do not have to sort everything. heapq.nlargest is O(n log k). Two heaps keep the median of a stream.

🔒 Basic

Chapter 5 — Graph traversal (lessons 15–16)

Using a rail map, you write breadth-first search and Dijkstra's algorithm. With depth-first search you also run into Python's recursion stopping at a depth of 1,000.

15

Graphs and breadth-first search (BFS and Dijkstra)

"Fewest changes" and "shortest travel time" are different problems. An adjacency list in a dict, and swapping the queue for a heap turns BFS into Dijkstra.

🔒 Basic
16

Depth-first search and recursion (it stops at depth 1,000)

Two causes of RecursionError. DFS can be written with recursion or a stack. On a straight-line graph the depth equals the number of nodes.

🔒 Basic

Chapter 6 — Design patterns for algorithms (lessons 17–18)

Dynamic programming and greedy algorithms: never compute the same thing twice, and take the best option in front of you. The second is faster, but not always correct.

17

Dynamic programming (40,000x from one extra line)

All you are doing is never computing the same thing twice. Memoisation and bottom-up, and the form that needs no table at all (Kadane).

🔒 Basic
18

Greedy algorithms (the best move now is not always the best overall)

Coins, meeting rooms and the knapsack. The same algorithm is correct or wrong depending on the input.

🔒 Basic

Chapter 7 — Finishing up (lessons 19–20)

The two string patterns (two pointers and the sliding window), and the procedure for solving a problem at all. You leave with a reference sheet.

19

String algorithms (two pointers and the sliding window)

Two patterns that turn a brute-force O(n^2) into O(n). And str.find is 26x faster than anything you write.

🔒 Basic
20

Wrapping up: read the constraints, solve it naively, measure, then fix

Five steps that matter more than any individual algorithm. Four triggers for optimising, five kinds of algorithm test, and a reference sheet.

🔒 Basic

Once you have finished all 20 lessons, it is time to apply your new judgement to real code. Firm up how you write it in Python for Beginners, work with data in Python & Machine Learning for Beginners, or re-examine both complexity and raw speed in Go for Beginners — any of them continues where this course leaves off. Membership unlocks every course.