Algorithms
Complexity analysis and the core techniques for reasoning about how code performs at scale. Ordered from foundational to advanced, 7 docs in this category.
Docs in Algorithms
Big O Notation
How to read and reason about Big O time and space complexity, with the common growth rates ranked and worked examples for each.
Binary Search
Why bisect_left and bisect_right return different insertion points for the exact same value, and why binary search silently returns a wrong answer, not an error, the moment the input isn't actually sorted.
Dynamic Programming
Why caching subproblem solutions turns an exponential naive recursive Fibonacci into a linear one, and what "overlapping subproblems" actually has to be true about a problem before memoization can help at all.
Graph Traversal: BFS & DFS
Why breadth-first search's queue explores every neighbor before any of their children, guaranteeing the shortest path in an unweighted graph, while depth-first search's stack (or recursion) does the opposite and can't make that guarantee at all.
Hash Tables & the Hash/Equality Contract
Why two objects that compare equal but hash differently don't raise an error when used as a dict key, they just silently fail to find each other, and why that makes the __eq__/__hash__ contract one of the most dangerous ones to get wrong.
Recursion & the Call Stack
Why CPython's recursion limit exists to protect the real, platform-dependent C stack rather than being an arbitrary language rule, and why raising it too high can still crash the interpreter instead of just allowing deeper recursion. Verified against CPython 3.12; exact stack behavior, default limit, and crash mode are interpreter- and version-specific, not universal across every Python implementation.
Sorting Algorithms & Stability
Why a "stable" sort guarantees equal-key elements keep their original relative order, and how Python's Timsort exploits already-sorted runs in real data to hit O(n) on the best case instead of always paying O(n log n).