Data Structures & Algorithms

Why data structures and algorithms matter, and how to actually study them.

The arithmetic, number theory, and combinatorics that quietly power every algorithm.

Truth tables, logical operators, and the reasoning style behind correct conditions.

How computers actually store numbers, and why signed integers behave the way they do.

Stack vs heap, pointers, cache locality, and why memory layout changes performance.

Variables, data types, operators, and control flow — the vocabulary every algorithm assumes.

Parameters, return values, how recursion uses the stack, and higher order functions.

Time, space, and the best, average, worst, and amortized cases of an algorithm.

The full asymptotic family and an intuition for how fast each class explodes.

How to turn a recursive algorithm into a closed-form complexity.

Contiguous memory, prefix sums, sliding windows, and the classic array algorithms.

2D and 3D layouts, traversal orders, and in-place transformations.

Character encodings, frequency counting, and the fundamental string problems.

KMP, Z algorithm, Rabin-Karp, suffix structures, and multi-pattern search.

Master linked list data structures for coding interviews: node pointer manipulation, list reversal, merging two sorted lists, and Floyd's cycle detection algorithm explained step by step.

LIFO ordering, monotonic stacks, and the problems they solve in linear time.

FIFO structures, circular buffers, priority queues, and monotonic queues.

Hash functions, collision resolution, load factor, and probabilistic variants.

Tree vocabulary, binary tree shapes, and every traversal order including Morris.

Ordered trees, search, insert, delete, successors, and why balance matters.

AVL, red-black, splay, treap, and the B-tree family that databases run on.

Binary heaps, heapify, heap sort, and the advanced heap variants.

Prefix trees, compressed variants, and the problems only a trie solves cleanly.

Tracking connected components with near-constant time union and find.

Vertices, edges, representations, and the vocabulary of graph theory.

DFS, BFS, strongly connected components, bridges, and articulation points.

Dijkstra, Bellman-Ford, Floyd-Warshall, Johnson, and choosing between them.

Kruskal, Prim, Boruvka, Kahn's algorithm, and dependency ordering.

Max flow, min cut, the Ford-Fulkerson family, and bipartite matching.

LCA, binary lifting, Euler paths, heavy-light and centroid decomposition.

Recursion trees, state exploration, pruning, and the classic backtracking problems.

Splitting problems, combining results, and the algorithms built on this shape.

Overlapping subproblems, optimal substructure, memoization, and tabulation.

Knapsack, LIS, LCS, coin change, and the standard DP families.

Bitmask, digit, tree, profile, and state-compression DP.

Local choices, exchange arguments, and knowing when greedy is actually correct.

Binary search, bounds, and searching on the answer space instead of the array.

Comparison sorts, linear-time sorts, stability, and what real libraries use.

Bitwise operators, masks, and the tricks that turn loops into single expressions.

Segment trees, lazy propagation, Fenwick trees, and sparse tables.

Persistent structures, spatial trees, wavelet trees, and specialized variants.

Meet in the middle, sweep line, convex hull, FFT, and Mo's algorithm.

Sieves, modular inverses, primality testing, and fast exponentiation.

Points, vectors, cross products, orientation, and polygon computations.

Monte Carlo, Las Vegas, sampling, shuffling, and probabilistic structures.

Working with data that does not fit in memory or on one core.

Space compression, coordinate compression, offline processing, and DP speedups.

The recurring shapes that cover the large majority of interview problems.

Loop invariants, proofs, stability, and classifying algorithms by their guarantees.

Cache efficiency, branch prediction, memory alignment, and concurrent structures.

Succinct structures, streaming algorithms, SAT solvers, and where the field goes next.

A fourteen-dimension checklist to apply to each data structure and algorithm.