Algorithms

Sliding Window

Solve fixed-window problems: maximum sum of k elements, moving averages, and O(n) updates as the window slides.

Two Pointers

Scan a sorted array or string from both ends at once to find pairs, remove duplicates, or reverse data in O(n).

Searching

Binary Search

Cut a sorted range in half on every step to find a value or boundary in O(log n) instead of checking one by one.

Depth-First Search

Explore as far as possible down one path before backtracking, used to walk trees, graphs, and grids.

Breadth-First Search

Explore level by level from a starting point, the go-to way to find the shortest path in an unweighted graph.

Dynamic Programming

Break a problem into overlapping subproblems and reuse their answers to avoid recomputing the same work.

Backtracking

Try a choice, keep going, and undo it if it fails, used to generate permutations, combinations, and valid layouts.

Greedy Algorithms

Make the locally best choice at each step and never look back, useful when local optima add up to a global optimum.

Bubble Sort

Repeatedly swap neighboring out-of-order elements until the whole list is sorted, simple but slow on large lists.

Merge Sort

Split the list in half, sort each half, then merge them back together in order, giving reliable O(n log n) time.

Quick Sort

Pick a pivot, move smaller elements left and larger ones right, then repeat on each side to sort in place.

Insertion Sort

Build the sorted list one element at a time, inserting each new element into its correct position as you go.

Dijkstra's Algorithm

Find the shortest path from a starting node to every other node in a graph where edges have non-negative weights.

Bellman-Ford Algorithm

Find the shortest path from a starting node even when some edges have negative weights, and detect negative cycles.

Topological Sort

Order the nodes of a graph so every task comes after everything it depends on, used for scheduling and build order.

Union-Find (Disjoint Set)

Track which nodes belong to the same group and merge groups quickly, used to detect cycles and build networks.

Kruskal's Algorithm

Build the cheapest network connecting all nodes by adding the smallest edges first, skipping any that form a cycle.

Prim's Algorithm

Build the cheapest network connecting all nodes by growing a tree one node at a time, always picking the cheapest edge out.

Recursion

Solve a problem by having a function call itself on a smaller version of the same problem until it hits a base case.

Selection Sort

Repeatedly find the smallest remaining element and move it into place, simple to write but slow on large lists.

Heap Sort

Build a heap from the list, then repeatedly pull out the largest element to sort in place in O(n log n).

Counting Sort

Count how many times each value appears, then rebuild the list in order, sorting in O(n) when values fall in a small range.

Prefix Sum

Precompute running totals so the sum of any range can be answered instantly instead of adding it up every time.

Kadane's Algorithm

Track the best running sum ending at each position to find the maximum sum of a contiguous subarray in one pass.

Bit Manipulation

Use AND, OR, XOR, and shifts to solve problems directly on the binary representation of numbers, often in O(1) space.