Loading
Algorithms, data structures, system design, operating systems, databases, and distributed systems — the foundations for software engineering interviews.
Other tracks: Quantitative Finance · Data Science
How we describe how an algorithm's cost scales with input size.
The two resource axes every algorithm trades against each other.
Averaging the cost of expensive operations across cheap ones.
The handful of growth rates that cover almost every algorithm you'll meet.
Contiguous memory, $O(1)$ random access, and the trade-offs that follow.
Two indices walking through one array to solve problems in linear time.
Reusing work across overlapping subarrays for linear-time scans.
Precompute partial sums once, answer range-sum queries in $O(1)$.
The core string problems and the patterns that solve them.
Mapping arbitrary keys to bucket indices in expected $O(1)$.
Chaining vs open addressing — the two ways to handle hash collisions.
The set of problems that collapse from $O(n^2)$ to $O(n)$ with a hash map.
When you need just membership versus key-to-value lookup.
Push, pop, peek — and the surprising range of problems they solve.
Two ends instead of one, and the algorithms that need them.
A stack maintained in sorted order — the trick behind several $O(n)$ array problems.
Push and pop at both ends; the workhorse for sliding-window maxima.
Node-based hierarchies and the vocabulary you'll need.
The four standard orders and how to implement each iteratively.
Ordered binary trees with $O(\log n)$ search — when balanced.
AVL, red-black, and B-trees — how they keep height logarithmic.
Trees keyed by character, perfect for prefix-based queries.
Adjacency list vs adjacency matrix — pick by density.
Level-by-level exploration; shortest paths in unweighted graphs.
Go deep before going wide — used for cycles, topological order, and connectivity.
Linearizing a DAG into a build order.
Single-source shortest paths in a graph with non-negative weights.
$O(\alpha(n))$-per-operation membership tracking; the trick behind MST and offline queries.
Why no comparison-based sort can beat $n \log n$ in the worst case.
Divide and conquer with a stable, predictable $O(n \log n)$.
In-place, fast in practice, $O(n^2)$ in the worst case.
Linear-time sorting when keys are bounded integers.
Optimal substructure, overlapping subproblems, and the two ways to implement.
Fibonacci, stairs, house robber, LIS — the linear recurrences.
LCS, edit distance, grid pathfinding — state indexed by two positions.
The single most-instructive DP problem family.