LeetCode patterns

Big-O, best and worst case, amortized cost, and reading a problem's constraints to guess the target complexity.

list, dict, set, deque, heapq and bisect: what each operation costs and which interview idioms they enable.

Base cases, the call stack, recursion trees and how to turn recursion into iteration.

Clarify, find the brute force, spot the pattern from the signals, optimize, code, test: the loop every page feeds into.

Trading memory for constant-time lookup: seen-sets, complement maps and grouping by key.

Frequency maps, bucketing by count and canonical keys for grouping.

Precomputed running totals that answer range queries in constant time, and prefix sums with hash maps.

Index marking, cyclic placement and encoding strings so arrays do double duty without extra memory.

Converging and same-direction pointers over sorted or partitioned arrays, including 3Sum.

Sliding a window of width k and updating its summary in constant time per step.

Growing the right edge, shrinking the left until the invariant holds, and tracking the best window.

Matching brackets, evaluating expressions and simulating with a last-in, first-out stack.

Keeping a stack sorted to answer next-greater and largest-rectangle questions, and the monotonic deque for window maxima.

Halving a sorted range with a clear loop invariant, and searching rotated arrays.

Searching the space of possible answers when a feasibility check is monotonic, and the median of two arrays.

Reversing, merging and removing nodes with dummy heads and careful pointer rewiring.

Floyd's cycle detection, finding the middle, and treating an array as a linked list.

The LRU cache and copying a list with random pointers: lists for order, maps for lookup.

Preorder, inorder and postorder traversal, and returning values up the tree to answer height and path questions.

Level-order traversal with a queue, and questions about levels and views of a tree.

The ordering invariant, validating it, kth smallest, and lowest common ancestor in a BST.

Rebuilding a tree from traversals, serializing and deserializing, and maximum path sums.

Prefix trees for insert, search and prefix queries, wildcard search and pruning a board search.

How a binary heap works, heapq idioms, and simulating schedules with a priority queue.

Keeping a heap of size k to find the largest, smallest, closest or most frequent elements.

A max-heap and a min-heap balanced around the middle for a running median.

Merging k sorted sequences with a heap of their current heads.

Partitioning to find the kth element in expected linear time, and when it beats a heap.

The choose-explore-unchoose template that generates every subset, permutation and combination, with and without duplicates.

Pruning searches with constraints: combination sum, word search, palindrome partitioning and N-queens.

Adjacency lists, visited sets, connected components, cloning a graph and detecting cycles.

Flood fill, counting islands and multi-source BFS on a matrix.

Ordering a DAG with Kahn's algorithm or DFS finishing times, and detecting cycles in prerequisites.

Disjoint sets with path compression and union by rank for connectivity and redundant edges.

Shortest paths with non-negative weights using a heap, and its variants on grids.

Relaxing edges round by round for negative weights and paths limited to k edges.

Prim's and Kruskal's algorithms for connecting every node at minimum cost.

Hierholzer's algorithm for using every edge exactly once, as in reconstructing an itinerary.

Overlapping subproblems, memoization versus tabulation, and the steps from brute force to DP.

One-dimensional recurrences: climbing stairs, house robber, decode ways and maximum product subarray.

0/1 and unbounded knapsack: coin change, partition equal subset sum and word break.

The quadratic DP and the patience-sorting binary search that makes it n log n.

Expanding around centers and DP over substrings for palindromic substring questions.

Counting and optimizing paths through a grid, and longest increasing path with memoized DFS.

Longest common subsequence, edit distance, interleaving and distinct subsequences.

DP over ranges of an array, as in burst balloons.

Modelling holding, selling and cooldown as states: the stock problems and target sum.

Exchange arguments and when a local choice is safe: jump game, gas station and hand of straights.

Maximum subarray in one pass, and its circular variant.

Sorting by start to merge, insert and remove overlapping intervals.

Turning intervals into start and end events to count overlaps, as in meeting rooms.

Rotating, transposing and spiraling a matrix in place, and setting zeroes with markers.

Digit manipulation, overflow, fast exponentiation and multiplying big numbers as strings.

XOR to cancel pairs, masks to test and clear bits, counting bits and adding without plus.

Range queries with point updates in logarithmic time.

Binary indexed trees for prefix sums under updates.

KMP's failure function and Rabin-Karp rolling hashes for finding a pattern in linear time.

DP over subsets encoded as bits, for assignment and travelling-salesman-style problems.