All Algorithms

Find an element in a sorted array by halving the search space each step.

Scan every element until the target is found.

Jump ahead by √n steps then do linear search within the block.

Repeatedly swap adjacent elements that are out of order.

Find the minimum element and place it at the front, repeat.

Build a sorted array one element at a time by inserting into position.

Divide in half, sort each half recursively, merge back.

Pick a pivot, partition around it, recursively sort partitions.

Build a max-heap, then extract elements one by one.

Sort integers digit by digit from least to most significant.

Count occurrences of each value, then reconstruct sorted output.

Explore all neighbors at the current depth before going deeper.

Explore as deep as possible before backtracking.

Find shortest paths from a source node using a priority queue.

Dijkstra + a heuristic to guide search toward the goal.

Single-source shortest paths that handles negative edge weights.

Find shortest paths between all pairs of nodes.

Build MST by greedily adding cheapest edges that don't form cycles.

Linear ordering of vertices in a directed acyclic graph.

Insert and search nodes in a Binary Search Tree.

Self-balancing BST that keeps height difference ≤ 1 via rotations.

Compute Fibonacci numbers efficiently using memoization or tabulation.

Maximize value of items in a knapsack with weight limit.

Find the longest subsequence present in both sequences.

Find minimum coins needed to make a target amount.

Lossless compression by assigning shorter codes to frequent characters.

Find pattern in text in O(n+m) using a failure function.

Find all primes up to N by eliminating multiples.

Compute greatest common divisor using repeated division.

Key-value store with O(1) average lookup using a hash function.

Space-efficient probabilistic set membership test with false positives.

Generalization of insertion sort that compares elements far apart, then narrows the gap.

Hybrid of merge sort and insertion sort. Used in Python, Java, and V8.

Distribute elements into buckets, sort each bucket, then concatenate.

Minimizes the number of writes to memory — optimal for write-expensive media.

Grow a minimum spanning tree by greedily adding the cheapest edge to the frontier.

Detect cycles in a sequence using two pointers at different speeds.

Track which elements belong to the same group with near-O(1) union and find.

Tree for fast range queries (sum, min, max) with O(log n) update.

Compact structure for prefix sum queries and point updates in O(log n).

Tree where each node represents a character. Enables O(m) prefix lookups.

Minimum insertions, deletions, and substitutions to transform one string to another.

Find the longest strictly increasing subsequence in O(n log n).

Find the contiguous subarray with the largest sum in O(n).

Find the optimal parenthesization of matrix products to minimize operations.

Use a rolling hash to find pattern in text in expected O(n+m).

Build a Z-array to find all pattern occurrences in O(n+m).

Find two numbers in an array that add to a target in O(n).

Find the maximum in every window of size k in O(n) using a monotonic deque.