Coding Patterns — Field Guide

02Hashing

0/3▶

Hash Map / Hash Set

Trade space for near O(1) average lookups, grouping, and duplicate detection.

Algorithms to learn

Hash map for complement lookups (Two Sum shape)
Hash set for existence / duplicate checks
Grouping by a computed key (sorted string, count signature)
Hashing with custom keys (tuples, sorted arrays)

EasyTwo Sum — Store value → index while scanning; check for target - num as you go.

MediumGroup Anagrams — Key each word by its sorted letters (or a 26-count signature) and bucket into a map.

HardLongest Consecutive Sequence — Put all numbers in a set; only start counting a run from numbers with no left neighbor, for O(n).

03Stack-Based

0/6▶

Monotonic Stack

Keep a stack in increasing or decreasing order to answer 'next greater/smaller' queries in one pass.

Algorithms to learn

Increasing vs decreasing stack, and which problems need which
Storing indices (not values) so distances are recoverable
Next Greater Element pattern
Histogram / rectangle-area style problems

EasyNext Greater Element I — Build next-greater map for nums2 via decreasing stack, then look up for nums1.

MediumDaily Temperatures — Decreasing stack of indices; pop and record distance whenever a warmer day appears.

HardLargest Rectangle in Histogram — Increasing stack of indices; on a drop, pop and compute area using width between boundaries.

Stack for Matching / Parsing

Track nested structure — brackets, expressions, or encoded strings — with a LIFO stack.

Algorithms to learn

Bracket matching with a symbol stack
Operator/number stacks for calculator-style expression evaluation
Decoding nested repeated patterns (e.g. k[encoded]) with a stack of (string, count)
Min-stack trick: store running min alongside each pushed value

EasyValid Parentheses — Push opening brackets; on a closing bracket, pop and check it matches.

MediumDecode String — Push (current string, current count) on '[', pop and repeat/append on ']'.

HardBasic Calculator — Stack holds pending results and signs to handle nested parentheses and +/- with no operator precedence beyond that.

04Linked Lists

0/6▶

Fast & Slow Pointers

Two pointers moving at different speeds through a list — the classic cycle-detection and midpoint-finding tool.

Algorithms to learn

Floyd's cycle detection (tortoise and hare)
Finding the cycle's starting node after detection
Using slow/fast to find the middle node in one pass
Applying the same idea to detect cycles in functional sequences (not just lists)

EasyLinked List Cycle — Slow moves 1 step, fast moves 2; if they meet, a cycle exists.

MediumFind the Duplicate Number — Treat array values as next-pointers; Floyd's algorithm finds the cycle entrance, which is the duplicate.

HardLinked List Cycle II (find cycle start) — After slow/fast meet, reset one pointer to head and advance both by 1 until they meet again.

In-place Reversal & Dummy Node

Rewire next pointers directly, using a dummy head node to simplify edge cases like removing the head.

Algorithms to learn

Classic full-list reversal with prev/curr/next pointers
Reversing a sublist between two positions
Dummy node to avoid special-casing head deletion/insertion
Group reversal (reverse in chunks of k)

EasyReverse Linked List — Iterate, flipping each node's next pointer to point backward.

MediumRemove Nth Node From End of List — Dummy head + two pointers spaced n apart, advance together until the front hits the end.

HardReverse Nodes in k-Group — Reverse each k-sized chunk manually, reconnecting chunk boundaries; recurse or loop for the next group.

05Binary Search

0/3▶

Modified Binary Search

Binary search over sorted arrays, rotated arrays, or an abstract 'answer space' where feasibility is monotonic.

Algorithms to learn

Standard binary search template (avoiding infinite loops / off-by-one)
Searching in a rotated sorted array (find the sorted half)
Binary search on the answer (search a value range, not an index range)
Binary search across two sorted structures (partition-based)

EasyBinary Search — Standard lo/hi/mid template on a sorted array.

MediumSearch in Rotated Sorted Array — At each mid, determine which half is properly sorted, then decide which side to search.

HardMedian of Two Sorted Arrays — Binary search the smaller array's partition point so left/right halves across both arrays balance.

06Trees

0/9▶

Tree DFS (Pre/In/Postorder)

Recursive or stack-based traversal that visits nodes in a specific parent/child order.

Algorithms to learn

Preorder / inorder / postorder traversal (recursive and iterative)
Passing state down (top-down) vs. returning state up (bottom-up)
Using inorder traversal to validate/exploit BST ordering
Combining two recursive calls for whole-tree properties (diameter, path sum)

EasyMaximum Depth of Binary Tree — Postorder: return 1 + max(left depth, right depth).

MediumValidate Binary Search Tree — DFS carrying a valid (low, high) range down to each node.

HardBinary Tree Maximum Path Sum — Postorder DFS returning best downward path per node, while tracking a global max that allows both children.

Tree BFS / Level Order

Queue-based traversal that processes a tree level by level.

Algorithms to learn

Queue-based level order traversal
Tracking level boundaries (level size snapshot)
Zigzag / right-side-view variants
BFS for shortest-path style tree/graph problems

EasyAverage of Levels in Binary Tree — Standard level-order traversal, averaging each level's queue snapshot.

MediumBinary Tree Zigzag Level Order Traversal — Level order traversal, reversing the order of alternating levels.

HardSerialize and Deserialize Binary Tree — BFS or DFS encode with null markers; decode by reconstructing in the same traversal order.

Tries (Prefix Trees)

A tree where each path from the root spells out a prefix, enabling fast prefix search and autocomplete-style queries.

Algorithms to learn

Trie node structure (children map + end-of-word flag)
Insert / search / startsWith operations
Combining a trie with DFS/backtracking for grid word search
Space/time tradeoffs vs. hash sets for prefix queries

EasyImplement Trie (Prefix Tree) — Build insert, search, and startsWith using nested child maps and an end marker.

MediumDesign Add and Search Words Data Structure — Trie insert as usual; search needs DFS branching whenever a '.' wildcard is hit.

HardWord Search II — Build a trie of all target words, then DFS the grid, pruning branches that leave the trie.

07Heaps / Priority Queues

0/6▶

Top-K Elements

Maintain a heap of size k to track the k largest/smallest/most-frequent items, often over a stream.

Algorithms to learn

Min-heap for 'top k largest', max-heap for 'top k smallest'
Keeping heap size capped at k (push then pop when oversized)
Bucket sort as an O(n) alternative for frequency-based top-k
Heapify vs. repeated push for construction cost

EasyKth Largest Element in a Stream — Maintain a min-heap of size k; the root is always the kth largest so far.

MediumTop K Frequent Elements — Count frequencies, then use a heap (or bucket sort) to extract the k most frequent.

HardFind Median from Data Stream — Two heaps (max-heap for lower half, min-heap for upper half), rebalanced after each insert.

K-Way Merge

Merge multiple already-sorted sequences efficiently using a heap to always pick the next-smallest candidate.

Algorithms to learn

Heap of (value, source index, position) tuples
Advancing only the source you just popped from
Complexity: O(n log k) instead of O(n·k)
Applying k-way merge to matrices and multiple lists alike

EasyMerge Two Sorted Lists — Two-pointer merge; the 2-way base case of k-way merging.

MediumKth Smallest Element in a Sorted Matrix — Min-heap seeded with the first column, popping/pushing across rows k times.

HardMerge k Sorted Lists — Min-heap holding the head node of each list; pop the smallest, push its successor.

08Backtracking

0/3▶

Backtracking

Build candidate solutions incrementally, abandoning ('pruning') a branch as soon as it can't lead to a valid answer.

Algorithms to learn

Decision tree framing: choose → explore → un-choose
Pruning conditions to cut off invalid branches early
Handling duplicates (skip same-value siblings after sorting)
Constraint propagation for grid-based backtracking (Sudoku, N-Queens)

EasySubsets — At each index, branch into 'include' and 'exclude' to enumerate all subsets.

MediumCombination Sum — Backtrack choosing candidates (with reuse), subtracting from target, pruning when target < 0.

HardN-Queens — Place one queen per row, backtracking with column/diagonal conflict sets to prune invalid placements.

09Graphs

0/12▶

Graph DFS / BFS

Traverse a graph's nodes and edges to explore connectivity, reachability, or shortest unweighted paths.

Algorithms to learn

Adjacency list construction from edges or a grid
DFS with a visited set for connected components
BFS for shortest path in an unweighted graph
Multi-source BFS (seed the queue with several starting nodes at once)

EasyFlood Fill — DFS/BFS from the start pixel, changing matching-color neighbors.

MediumNumber of Islands — DFS/BFS from each unvisited land cell, marking the whole connected island visited.

HardWord Ladder — BFS over the word graph (edges = one-letter transformations) for shortest transformation sequence.

Topological Sort

Order nodes in a directed acyclic graph so every edge points from earlier to later in the ordering.

Algorithms to learn

Kahn's algorithm (BFS using in-degree counts)
DFS-based topological sort (postorder, then reverse)
Cycle detection as a side effect (if not all nodes get ordered, a cycle exists)
Recognizing 'prerequisite' / dependency-ordering problem phrasing

EasyCourse Schedule (can finish?) — Kahn's algorithm; if the processed count equals total courses, no cycle exists.

MediumCourse Schedule II (return order) — Same as Kahn's algorithm, but record nodes in the order their in-degree hits zero.

HardAlien Dictionary — Derive edge order from adjacent word comparisons, then topologically sort the resulting letter graph.

Union-Find (Disjoint Set)

Efficiently track and merge connected components, answering 'are these in the same group?' near O(1).

Algorithms to learn

Union by rank/size and path compression
Detecting cycles by checking if two nodes already share a root
Counting connected components as unions succeed
When union-find beats DFS/BFS (dynamic connectivity, incremental edges)

EasyNumber of Provinces — Union every direct connection in the matrix; count remaining distinct roots.

MediumNumber of Connected Components in an Undirected Graph — Union each edge's endpoints; count distinct roots at the end.

HardRedundant Connection — Union edges one by one; the edge that connects two nodes already in the same set is the answer.

Shortest Path (Dijkstra / Bellman-Ford)

Find minimum-cost paths in weighted graphs, positive-only (Dijkstra) or with negative edges (Bellman-Ford).

Algorithms to learn

Dijkstra's algorithm with a min-heap of (distance, node)
Why Dijkstra fails with negative edge weights
Bellman-Ford's relax-all-edges V-1 times approach and negative-cycle detection
Modeling 'at most K stops/steps' as an extra state dimension

EasyPath With Minimum Effort (small grid, BFS/Dijkstra hybrid) — Binary search on effort + BFS feasibility check, or Dijkstra minimizing max-edge-on-path.

MediumNetwork Delay Time — Dijkstra from the source node; answer is the max of all shortest distances (or -1 if unreachable).

HardCheapest Flights Within K Stops — Bellman-Ford limited to K+1 relaxation rounds, since Dijkstra doesn't naturally respect a stop limit.

10Dynamic Programming

0/18▶

1D Dynamic Programming

State depends on a small window of previous states along a single sequence.

Algorithms to learn

Recurrence relation identification (what does dp[i] depend on?)
Top-down memoization vs. bottom-up tabulation
Space optimization (rolling variables instead of a full array)
Base case and iteration direction

EasyClimbing Stairs — dp[i] = dp[i-1] + dp[i-2]; Fibonacci-shaped recurrence.

MediumHouse Robber — dp[i] = max(dp[i-1], dp[i-2] + nums[i]); rob or skip each house.

HardLongest Increasing Subsequence (O(n log n)) — Maintain a 'tails' array with binary search to patch in the smallest valid tail for each length.

2D Dynamic Programming (Grid/Table)

State depends on a 2D table, typically comparing two sequences or moving through a grid.

Algorithms to learn

Grid traversal DP (dp[r][c] from dp[r-1][c] and dp[r][c-1])
Two-sequence comparison DP (dp[i][j] over prefixes of two strings)
Reconstructing the actual path/sequence from a filled DP table
Space optimization to O(n) using two rolling rows

EasyUnique Paths — dp[r][c] = dp[r-1][c] + dp[r][c-1], counting paths to each grid cell.

MediumLongest Common Subsequence — dp[i][j] = dp[i-1][j-1]+1 on a match, else max(dp[i-1][j], dp[i][j-1]).

HardEdit Distance — dp[i][j] = min of insert/delete/replace costs, matching characters for free when they're equal.

Knapsack (0/1 & Unbounded)

Choose or skip items under a capacity constraint — the archetypal subset-selection DP.

Algorithms to learn

0/1 knapsack: each item used at most once (iterate capacity backward in 1D)
Unbounded knapsack: items reusable (iterate capacity forward in 1D)
Reframing subset-sum / partition problems as knapsack capacity = target
Counting ways vs. optimizing value — same shape, different combine operator

EasyPartition Equal Subset Sum — 0/1 knapsack: can a subset sum to totalSum/2? Boolean dp over achievable sums.

MediumCoin Change II (count combinations) — Unbounded knapsack counting ways; iterate coins outer, amounts inner, to avoid counting order-based duplicates.

HardTarget Sum — Reframe +/- assignment as subset-sum: positives subset sums to (total+target)/2, then 0/1 knapsack count.

DP on Strings

Comparing, transforming, or matching sequences character by character with overlapping subproblems.

Algorithms to learn

Palindrome DP (dp[i][j] = is substring i..j a palindrome)
Interleaving/matching DP across two or three strings simultaneously
Regex/wildcard matching state transitions
Expand-around-center as an alternative to full DP tables for palindromes

EasyPalindromic Substrings (count) — Expand around each center (odd and even) to count all palindromic substrings.

MediumLongest Palindromic Substring — Expand around center for each index, tracking the longest match found.

HardRegular Expression Matching — dp[i][j] tracks match of s[:i] vs p[:j], with special handling for '*' (zero or more of preceding).

DP on Trees

Combine results from child subtrees to compute an optimal value for the whole tree.

Algorithms to learn

Postorder DFS returning a tuple of states per node (e.g. 'include' vs 'exclude')
Combining left/right subtree results at each node
Tracking a global answer alongside a per-node return value
Rerooting technique for 'answer for every node as root' problems (bonus)

EasyDiameter of Binary Tree — Postorder DFS returning height, updating a global max of left height + right height at each node.

MediumHouse Robber III — Postorder DFS returning (best if robbed, best if not robbed) per node.

HardBinary Tree Maximum Path Sum — Postorder DFS returning best single-branch sum, while a global tracks best 'through-node' path using both children.

Bitmask DP

Compress a subset of items into an integer bitmask to track 'which items have been used' as DP state.

Algorithms to learn

Representing subsets as integers and iterating with bit tricks
dp[mask][i] state design (which items used, current position)
Enumerating submasks of a mask when needed
Recognizing small-n (n ≤ ~20) as a bitmask DP signal

EasyPartition to K Equal Sum Subsets (small n, brute + memo) — Backtrack with a used-items bitmask, memoizing (mask, remaining bucket space) states.

MediumShortest Path Visiting All Nodes — BFS over (node, visited-mask) states; goal is any state where mask is all-ones.

HardTraveling Salesman Problem (DP over subsets) — dp[mask][i] = min cost to visit exactly the cities in mask, ending at i, built from dp[mask without i][j].

11Greedy

0/3▶

Greedy Algorithms

Make the locally optimal choice at each step and prove (or trust) that it leads to a globally optimal answer.

Algorithms to learn

Sorting by a clever key as a greedy enabler
Exchange-argument intuition for why a greedy choice is safe
Greedy vs. DP: recognizing when the greedy choice actually holds
Interval-scheduling and gas-station-style greedy templates

EasyAssign Cookies — Sort both arrays; greedily satisfy the smallest child with the smallest sufficient cookie.

MediumJump Game — Track the farthest reachable index while scanning; greedy reach expansion, no backtracking needed.

HardCandy — Two greedy passes (left-to-right, then right-to-left) enforcing the 'more candy than a lower-rated neighbor' rule.

12Intervals

0/3▶

Merge Intervals

Sort intervals by start time, then sweep through merging or comparing overlaps.

Algorithms to learn

Sorting by start (or end) time as the key first step
Overlap condition: current.start <= previous.end
Sweep-line thinking for counting overlaps at a point in time
Inserting a new interval into an already-sorted, non-overlapping list

EasyMerge Intervals (basic merge) — Sort by start; extend the last merged interval whenever the next one overlaps it.

MediumInsert Interval — Append all intervals ending before the new one, merge all overlapping ones, then append the rest.

HardMeeting Rooms II (min rooms required) — Sweep-line: sort start and end times separately, or use a min-heap of active end times.

13Bit Manipulation

0/3▶

Bit Manipulation

Use XOR, shifts, and masks to solve problems in O(1) extra space with bitwise tricks.

Algorithms to learn

XOR properties (self-cancelling, identity) for pairing/duplicate problems
Bit counting techniques (Brian Kernighan's algorithm: n & (n-1))
Bit masks for representing sets/subsets
Two's complement mechanics for negative number bit tricks

EasySingle Number — XOR every element; pairs cancel to zero, leaving the unpaired number.

MediumCounting Bits — dp[i] = dp[i >> 1] + (i & 1); reuse smaller results via bit-shift relation.

HardSum of Two Integers (no + or -) — Simulate addition with XOR (sum without carry) and AND-then-shift (carry) until carry is zero.

14Math & Geometry

0/3▶

Math & Geometry / Simulation

Direct simulation of a described process — matrix rotation, spiral traversal, coordinate geometry.

Algorithms to learn

Matrix transposition + reversal as a rotation trick
Layer-by-layer boundary tracking for spiral traversal
Modular arithmetic for cyclic/overflow-safe computation
Fast exponentiation (binary exponentiation) for power functions

EasySqrt(x) — Binary search for the integer square root, or Newton's method for faster convergence.

MediumRotate Image — Transpose the matrix, then reverse each row (or reverse rows then transpose), in place.

HardSpiral Matrix — Track four shrinking boundaries (top/bottom/left/right), traversing and tightening each edge in turn.

01Array & String

Two Pointers

Sliding Window

Cyclic Sort

Prefix Sum

02Hashing

Hash Map / Hash Set

03Stack-Based

Monotonic Stack

Stack for Matching / Parsing

04Linked Lists

Fast & Slow Pointers

In-place Reversal & Dummy Node

05Binary Search

Modified Binary Search

06Trees

Tree DFS (Pre/In/Postorder)

Tree BFS / Level Order

Tries (Prefix Trees)

07Heaps / Priority Queues

Top-K Elements

K-Way Merge

08Backtracking

Backtracking

09Graphs

Graph DFS / BFS

Topological Sort

Union-Find (Disjoint Set)

Shortest Path (Dijkstra / Bellman-Ford)

10Dynamic Programming

1D Dynamic Programming

2D Dynamic Programming (Grid/Table)

Knapsack (0/1 & Unbounded)

DP on Strings

DP on Trees

Bitmask DP

11Greedy

Greedy Algorithms

12Intervals

Merge Intervals

13Bit Manipulation

Bit Manipulation

14Math & Geometry

Math & Geometry / Simulation