Algorithms and Complexity
There are two ways to know an algorithm: copying it from a reference and trusting it works, or understanding it well enough to derive it yourself. Vibe coders operate in the first mode — they can prompt an AI for a sorting implementation but couldn't tell you why quicksort is faster than bubble sort in practice, or when mergesort is preferable, or why binary search only works on sorted data. This module builds the second kind of knowledge. Big-O notation isn't just interview prep — it's the vocabulary for reasoning about the scalability of code at any scale. An engineer who thinks in complexity classes can look at a nested loop and immediately see a potential O(n²) bottleneck. They can recognize that a linear scan through a sorted array can be replaced with a binary search. They understand that some problems have no efficient solution and recognize when they're close to one. This module covers the core algorithms every engineer needs: sorting (and why there are so many), binary search, recursion and dynamic programming, greedy algorithms, and graph algorithms for shortest path and topological ordering. For each one, you'll not just learn the implementation but reason about correctness, derive the complexity, and understand the conditions under which each approach is optimal.
What You'll Learn
-
1
Big-O Notation — Thinking about scale, not just correctness
-
2
Sorting — Why there are so many sorts and when each matters
-
3
Searching and Binary Search — The most useful algorithm in all of CS
-
4
Recursion and Dynamic Programming — Breaking problems down
-
5
Greedy Algorithms — When the local optimum is the global optimum
-
6
Graph Algorithms — Shortest path, topological sort, MST
Capstone Project: Algorithm Benchmark Suite
Build a benchmarking suite that implements and compares multiple sorting and searching algorithms across different input sizes, measuring actual runtime, memory usage, and cache behavior — then produces charts that visually validate your Big-O predictions against real performance data. The project forces you to confront the difference between theoretical complexity and practical performance, including cache effects, constant factors, and input distribution.
Why This Matters for Your Career
Algorithmic thinking is what allows engineers to work at scale. A system processing a million records a day doesn't tolerate O(n²) algorithms the way a personal project does — and the engineers who catch those choices in code review, or design around them from the start, are the ones who build systems that survive growth. Dynamic programming in particular is one of the most transferable techniques in all of programming. Optimal substructure and overlapping subproblems appear in caching strategies, route planning, text diffing, sequence alignment, and dozens of other real applications. Once you understand the pattern, you see it everywhere — and you can apply it even when no one has given you a named algorithm to copy. Graph algorithms are the foundation of networking, dependency resolution, build systems, recommendation engines, and navigation. Dijkstra's algorithm is running every time you get directions. Topological sort is running every time npm resolves your dependencies. Understanding these at the algorithm level means you understand the tools that run your software — not just how to call them.