Every algorithm, animated

Repeatedly steps through the list, compares adjacent elements and swaps them if in wrong order.

Divides the input list into sorted and unsorted portions, repeatedly selecting the minimum element from unsorted portion.

Builds the final sorted array one element at a time by inserting each element into its correct position.

A divide-and-conquer algorithm that recursively splits the array into halves, sorts each half, then merges the sorted halves.

A highly efficient divide-and-conquer algorithm that selects a pivot and partitions the array around it.

Builds a binary max-heap from the array, then repeatedly extracts the maximum element and places it at the end.

Finds the position of a target value within a sorted array by repeatedly dividing the search interval in half.

Sequentially checks each element of a list until a match is found or the whole list is searched.

Finds the shortest paths from a source node to all other nodes in a weighted graph with non-negative edge weights.

Traverses or searches a graph level by level, exploring all neighbors at the current depth before moving deeper.

Explores a graph by going as deep as possible along each branch before backtracking.

Finds the shortest paths from a source node to all other nodes, handling negative edge weights and detecting negative cycles.

Finds a minimum spanning tree (MST) by sorting all edges by weight and adding the smallest edges that do not form a cycle.

Finds an MST by growing a single tree from a starting vertex, always adding the cheapest edge connecting a new vertex.

Orders the vertices of a DAG linearly such that for every directed edge u->v, vertex u comes before v.

Finds shortest paths between all pairs of vertices in a weighted graph using dynamic programming.

Computes the nth Fibonacci number using memoization.

Determines max value obtainable by selecting items with given weights/values within capacity.

Finds the longest subsequence common to two sequences.

Finds length of the longest strictly increasing subsequence.

Traverses a binary tree: left subtree, root, right subtree (LNR).

Traverses a binary tree: root, left subtree, right subtree (NLR).

Finds the deepest node that has both target nodes as descendants.

Maintains sorted data with O(log n) avg search, insert, and delete.

Selects max non-overlapping activities by choosing earliest finishing ones.

Creates optimal variable-length prefix codes for lossless compression.

Finds min coins for target amount using largest denominations first.

Places N queens on N x N board so none threaten each other.

Generates all subsets or determines if subset sums to target.

Moves N disks using auxiliary peg. Larger disk never on smaller.

Sorts integers digit by digit without comparing elements directly.

Counts occurrences of each value to build a sorted output.

Searches a unimodal function by repeatedly discarding two-thirds of the range.

Finds a shortest path using the cost so far plus a heuristic estimate.

Maintains connected components with near-constant union and find operations.

Finds a pattern in text without rechecking characters after a mismatch.

Stores strings character by character for fast prefix queries.

Generates all prime numbers up to a limit by marking composite multiples.

Computes the greatest common divisor using repeated remainders.

Computes powers in logarithmic time by repeatedly squaring the base.

Uses XOR identities to cancel duplicates and isolate unique values.

Maintains a moving range to solve contiguous subarray and substring problems.

Index, insert, delete, and traverse contiguous memory.

Follow and update pointers through singly and doubly linked nodes.

Map keys to buckets and resolve collisions with probing or chaining.

Answer prefix and range sums with compact binary indexed updates.

Combine interval summaries to answer range queries and point updates.

Detect a repeated state using Floyd's tortoise-and-hare technique.

Index every suffix of a string for fast substring and repeat queries.

Sort suffix starting positions and use LCP values for string queries.

Wrap a set of points with the smallest convex polygon using monotone chain.

Push capacity through a network until no augmenting path remains.

Pair vertices across two partitions through augmenting paths.

Choose the smallest set of vertices touching every edge in a bipartite graph.

Connect required terminals with optional helper vertices at minimum cost.

Find a minimum-cost tour that visits every location exactly once.

Understand how one hard decision problem can be transformed into another.