# Algorithms

> The classic algorithms every developer meets - searching, sorting, recursion, trees, graphs, and dynamic programming - taught from intuition, run in your browser, and shown side by side across languages.

10 guides.

- [Big-O Without the Math Panic](https://themissingmanual.dev/guides/big-o-without-the-math-panic) _(beginner)_ - Big-O isn't a math exam - it's a simple way to ask 'when my data gets bigger, does the work get a little bigger, a lot bigger, or catastrophically bigger?' This guide gives you that intuition with zero proofs.
- [Data Structures, Explained](https://themissingmanual.dev/guides/data-structures-explained) _(beginner)_ - The handful of containers you actually use day to day - arrays/lists, maps, sets, stacks, queues, and linked lists - what each one is really good at, and how to pick the right one without overthinking it.
- [Recursion, Finally](https://themissingmanual.dev/guides/recursion-finally-clicks) _(beginner)_ - The mental model that makes recursion stop being scary: a base case, a step toward it, and trust - plus when it blows the stack and how to avoid it.
- [Sorting & Searching, Explained](https://themissingmanual.dev/guides/sorting-and-searching-explained) _(beginner)_ - How computers find things fast and put things in order: linear vs. binary search, then the classic sorts - bubble, merge, and quick - with the intuition behind each one's speed, not just the code.
- [Trees & Binary Search Trees](https://themissingmanual.dev/guides/trees-and-binary-search-trees) _(beginner)_ - What a tree actually is - nodes, root, children, leaves - then the binary search tree specifically: the ordering rule that makes search and insert fast, with real code building and searching one.
- [Graph Theory: The Math of What's Connected to What](https://themissingmanual.dev/guides/graph-theory-whats-connected-to-what) _(intermediate)_ - A graph is a map of relationships: who is friends with whom, which files import which other files, how data flows through a network. This guide teaches you to think in connections, find the shortest path, and see the graph theory running your package manager, your social feed, and the internet itself.
- [Two Pointers & the Sliding Window](https://themissingmanual.dev/guides/two-pointers-and-sliding-window) _(beginner)_ - Two array patterns that turn nested-loop O(n²) scans into single-pass O(n) code: converging two pointers on a sorted array, the fixed and variable sliding window, and how to spot which one a problem is quietly asking for.
- [Hashing for Speed](https://themissingmanual.dev/guides/hashing-for-speed) _(beginner)_ - Why a hash map turns an O(n) scan into an O(1) average lookup: buckets and hash functions explained plainly, frequency counting, the one-pass two-sum, set membership and de-duplication, plus the gotchas - unhashable keys, worst-case collisions, and unordered results.
- [Dynamic Programming: A Gentle Intro](https://themissingmanual.dev/guides/dynamic-programming-intro) _(intermediate)_ - Dynamic programming taught from intuition: overlapping subproblems and memoization on naive Fibonacci, bottom-up tabulation with climbing stairs, then coin change as real DP and how to recognize an optimal-substructure problem when you see one.
- [Dijkstra's Shortest Path, From Scratch](https://themissingmanual.dev/guides/dijkstra-shortest-path) _(intermediate)_ - Dijkstra's algorithm taught from intuition: why BFS breaks once edges have weights, the greedy 'always expand the closest node' idea, a priority-queue implementation walked step by step across seven languages, and where it runs the real world - maps, routing, and A*.