On this page

DSA: Zero to Mastery

Data structures and algorithms are the one subject every software engineer is examined on and almost nobody is taught properly. Most resources are either a textbook with proofs and no code, or a problem list with code and no proofs. This course is both, in order: 13 modules, one lesson at a time, from "what does actually mean" to network flow, suffix automata, DP optimizations and the algorithms running inside your database and your version control system.

How every lesson is built

  • Pattern triggers — the words in a problem statement that should make you think of this technique.
  • The ladder — brute force → better → optimal, each with its complexity and why it is better.
  • Trace table — the algorithm executed by hand on a small input, step by step, so you can see the state change.
  • Correctness — a proof or proof sketch, because an algorithm you cannot argue for is one you will misapply.
  • Complexity — time and space, best/average/worst, amortized where it matters, and the constants that Big-O hides.
  • Code in four languages — Python, Java, C++ and TypeScript, complete and tested, in a tabbed code group.
  • Real-world uses — where this runs inside real systems, linked to Archon's system design and CS pages.
  • Pitfalls, variations, a practice ladder of 8–15 problems from easy to hard with hints and solutions, and the interview follow-ups you will actually be asked.

How the course works

  • Lessons are in an order where nothing depends on something you have not read yet. Each lesson shows where you are in its module ("Module 4 · Lesson 6 of 15") and links to the next one.
  • Capstones — most modules end with a mini-project: build an LRU cache and benchmark it, run Dijkstra on a real road network, write a diff tool. Build it yourself first, then compare with the reference.
  • Progress uses the same tickboxes as the sidebar: tick a lesson (or press Mark lesson done & continue) and the module and course bars fill up.
  • Deep dives under a module are optional. Module 12 (competitive programming) is optional for interview preparation.

Not sure how to pace yourself? Start with How to Use This Course & Study Plan Overview — it has 4-, 8- and 12-week plans.

New to algorithms?

Do Module 0 and Module 1 in order and do not skip the practice ladders — reading an algorithm and being able to produce it under pressure are different skills. Already comfortable? Skim a module's overview lesson; if its capstone looks easy, move on.

Companion courses

The CS Core Fundamentals course covers how the machine runs your code (operating systems, concurrency, networks, databases); the System Design Course covers building systems from these pieces. Module 10 of this course links the two: it shows the algorithms you learn here running inside databases, Git, operating systems, distributed systems and search engines.