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.
Basic
Big-O Without the Math Panic 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 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 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 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 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.
Two Pointers & the Sliding Window 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 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.
Intermediate
Graph Theory: The Math of What's Connected to What 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.
Dynamic Programming: A Gentle Intro 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 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*.