Learn the Patterns

Use two indices that move toward each other or in the same direction to find pairs, subarrays, or partitions in sorted or linear data structures.

Maintain a window (subarray/substring) that slides across the data. Expand the right boundary to add elements, shrink the left boundary to remove — tracking a running condition.

Divide the search space in half each step. Works on sorted data or any space where you can determine which half contains the answer.

Use a hash map (dictionary) for O(1) lookups, counting frequencies, or mapping relationships between elements.

LIFO structure. Push and pop from the top. Used whenever you need to track nested structures, undo operations, or match pairs.

A stack that maintains elements in increasing or decreasing order. Elements that violate the order are popped before the new element is pushed.

Sequential nodes connected by pointers. Commonly uses slow/fast pointer technique for cycle detection, finding middle, and merging.

Explore tree depth-first using recursion or an explicit stack. Includes preorder, inorder, and postorder traversals.

Level-by-level traversal using a queue. Process all nodes at one depth before moving to the next.

Explore graph level-by-level from a source. Guarantees shortest path in unweighted graphs. Uses a queue and visited set.

Explore as deep as possible along each branch before backtracking. Uses recursion or explicit stack with a visited set.

Break a problem into overlapping subproblems. Solve each subproblem once and store the result — build up to the final answer.

Make the locally optimal choice at each step. Works when local optimality leads to global optimality — no backtracking needed.

Build candidates incrementally and abandon (backtrack) as soon as you determine a candidate cannot lead to a valid solution. Systematic way to try all possibilities.

A data structure that efficiently supports insert and extract-min/max operations. Always gives you the smallest or largest element in O(log n).

Tracks a set of elements partitioned into disjoint subsets. Supports two operations: union (merge two sets) and find (determine which set an element belongs to).

Linear ordering of vertices in a directed acyclic graph (DAG) such that every edge u→v means u comes before v. Uses BFS (Kahn's) or DFS.

A tree-like data structure for storing strings, where each node represents a character. Enables fast prefix-based lookups and autocomplete.

Use bitwise operators (AND, OR, XOR, shift) to solve problems in O(1) space or optimize solutions that work on binary representations.

FIFO structure (queue) or double-ended queue (deque). Queue for BFS and processing in order. Deque for sliding window maximum/minimum.

Precompute cumulative sums so that any subarray sum can be calculated in O(1). Transform range-sum queries from O(n) to O(1).

Problems involving ranges [start, end]. Core operations: sorting by start/end, merging overlapping intervals, detecting conflicts, and inserting new intervals.

Navigate 2D grids — spiral order, diagonal traversal, rotation, searching in sorted matrices. Often combined with BFS/DFS for island-type problems.

Split the problem into smaller subproblems, solve each independently, then combine results. Unlike DP, subproblems don’t overlap.

Find the maximum (or minimum) sum contiguous subarray in O(n). Maintain a running sum — if it drops below zero, reset. Track the global maximum throughout.