Data Structures & Algorithms

1. Big-O without the fear

Big-O notation is not mathematics for its own sake — it is the vocabulary engineers use to argue about whether code will still work when the data grows. This lesson builds asymptotic analysis from counting actual steps: what the notation means precisely, the standard growth families and their real-world signatures, what constants and lower-order terms mean in practice, common pitfalls in reading and writing it, and how to apply it to loops, nested loops and recursive code. By the end, "this is O(n²)" will be a prediction you can test rather than a phrase you have heard.

2. Arrays, strings and two pointers

The array is the most-used container in existence because contiguous, indexed storage makes reads instant — and the same layout makes insertions at the front expensive. This lesson covers the array's cost model precisely, the in-place operations that exploit it, the two-pointer technique that collapses nested loops into single passes, string-specific patterns (sliding windows, palindromes, immutability costs), and the boundary bugs — off-by-one, mutation of the source, encoding — that show up in every array-heavy interview and production bug. Contiguity is the whole story; everything else follows from it.

3. Maps and sets: looking things up in one step

The hash table is the data structure behind JavaScript's `Map` and `Object`, Python's `dict`, Java's `HashMap` — and the reason "slow" code often becomes fast the moment an inner loop's scan is replaced by a lookup. This lesson builds hashing from first principles: how a key becomes a position, what collisions are and how they are handled, the precise cost model (average Θ(1), worst Θ(n)), what keys are legal and why equality matters, and the practical patterns — counting, deduplication, grouping, two-sum — that convert quadratic scans into linear passes. Then the failure modes: bad hash functions, mutation while keyed, and the identity-versus-value trap.

1. Sorting and searching

Sorting is the preprocessing move that makes everything downstream cheaper — searching, grouping, merging and comparison all become simple on ordered data. This lesson covers the comparison-sorting lower bound and the algorithms that approach it (merge sort, quicksort, heapsort), why built-in sorts are hybrid and stable, binary search as the canonical logarithmic algorithm with all its boundary care, and the practical discipline of choosing and verifying sorts. Understanding why n log n is the floor for comparison sorts is one of the few genuinely beautiful results in the subject — and it explains every design decision in this lesson.

2. Recursion and memoization

Recursion solves a problem by solving smaller copies of itself — the most natural formulation for trees, nested structures and divide-and-conquer, and the easiest way to write a program that never terminates. This lesson covers the anatomy of correct recursion (base case, progress, trust), the call stack as a data structure, how to trace and count recursive cost, the exponential explosion of overlapping subproblems, and memoisation as the fix that turns Fibonacci from never-finishing to instant. Then the constructive side: when iteration beats recursion, tail-call shapes, and how to debug the stack when it overflows.

3. Trees, graphs and traversal

Trees and graphs are the structures for anything with relationships: file systems, hierarchies, syntax, routes, dependencies, social networks. This lesson covers the vocabulary (root, leaf, depth, degree, DAG), the two traversal families — depth-first with its stack and three orders, breadth-first with its queue and level structure — and their costs, then the algorithms built on them: search, cycle detection, topological sorting, shortest paths (BFS for unweighted, Dijkstra for weighted), and union-find for connectivity. Traversal is the skeleton key: most graph problems are "traverse and do something at each node".