The most fundamental data structure - contiguous memory, O(1) access, and the three patterns (two pointers, sliding window, prefix sums) that unlock most array interview problems.
Nodes connected by pointers - the three patterns that cover 90% of linked list interviews: reversal, fast/slow pointers, and two-pointer with offset.
LIFO storage built on a Python list - the two patterns that cover most stack interviews: monotonic stack for next-greater problems and an explicit stack for DFS and bracket matching.
FIFO storage built on collections.deque - the two patterns that appear in nearly every queue interview: BFS level traversal and the monotonic deque for sliding window extremes.
O(1) average key-value lookup built on a hash function - the three patterns that cover most hash map interviews: complement lookup, frequency counting, and grouping by derived key.
Hierarchical nodes with left/right children - the two traversal families (recursive DFS and level-order BFS) that unlock most binary tree interviews, plus the BST property for ordered queries.
A complete binary tree with the heap property - O(log n) insert and extract, O(1) peek of the min or max, and the two patterns that cover most heap interviews: top-K elements and the two-heap split for running median.
Nodes connected by arbitrary edges - BFS for shortest path, DFS for connected components and cycle detection, and topological sort for dependency ordering.
A prefix tree where each path from root to a marked node spells a word - O(m) insert and search by word length, enabling prefix lookups and autocomplete that a hash set cannot do efficiently.
A disjoint set data structure that tracks connected components in near-O(1) per operation - path compression and union by rank combine to give O(alpha(n)) amortized, faster than BFS/DFS for dynamic connectivity.
A function that calls itself on a smaller input - the call stack handles bookkeeping so you only need to define the base case and the recursive step, trusting that smaller subproblems are already solved.
Halving the search space - how binary search achieves O(log n), how to get the boundary conditions right, and how to apply the same idea beyond sorted arrays to any problem with a monotonic feasibility check.
Two index variables that eliminate the inner loop - the opposite-ends pattern for sorted-array pair problems and the same-direction pattern for partitioning and in-place removal.
A contiguous subarray maintained by advancing start and end pointers - fixed-size windows for k-element aggregates and variable-size windows for constraint-satisfying substrings.
Level-by-level graph traversal using a queue - guarantees the shortest path in unweighted graphs and naturally groups nodes by their distance from the source.
Depth-first graph traversal that explores one path completely before backtracking - recursive DFS for connected components and tree problems, backtracking DFS for generating all valid combinations.
Breaking problems into overlapping subproblems and caching results - top-down memoization for natural recursion and bottom-up tabulation for space-efficient iteration.
Making the locally optimal choice at each step to reach a global optimum - interval scheduling by earliest deadline, activity selection, and the exchange argument that proves greedy correctness.
Arranging elements in order - merge sort for stable O(n log n), quicksort for in-place average O(n log n), and how to use Python's sort with custom keys to solve comparison problems without implementing a sort from scratch.
Systematic search that builds candidates incrementally and abandons a path the moment it cannot lead to a valid solution - choose, explore, unchoose is the three-step template for all backtracking problems.
Operating directly on binary representations - XOR for cancellation, AND for masking, and the handful of tricks (power-of-2 check, lowest set bit, popcount) that cover most bit manipulation interview problems.