Algorithm Visualizer

Find the shortest path from a source node to all others in a weighted graph with non-negative edges. The quintessential greedy graph algorithm.

Explore a graph level by level from a source node. Guarantees the shortest path in unweighted graphs.

Explore as deep as possible before backtracking. Foundation for cycle detection, topological sort, and more.

Shortest paths from a source that handles negative edge weights and detects negative cycles.

All-pairs shortest path algorithm using dynamic programming. Works with negative weights (no negative cycles).

Heuristic-guided shortest path algorithm. Faster than Dijkstra's when a good heuristic is available.

Build a Minimum Spanning Tree by greedily adding the cheapest edges that don't form cycles.

Grow a Minimum Spanning Tree one vertex at a time by always picking the cheapest reachable edge.

Order the vertices of a directed acyclic graph so every edge points forward. Kahn's in-degree peeling and DFS-based post-order, side by side.

Detect cycles in a directed graph with three-color DFS: white unvisited, gray on the recursion stack, black fully explored. A back edge to a gray node means cycle.

Divide-and-conquer sorting that guarantees O(n log n) time. Stable, predictable, and widely used in production.

Partition-based sort that is extremely fast in practice despite O(n²) worst case. Pick a pivot, partition the array, recurse — average O(n log n) with great cache locality.

Sort in-place using a max-heap. Phase 1 builds the heap; phase 2 repeatedly extracts the max. Guaranteed O(n log n) with no extra memory.

Repeatedly swap adjacent elements that are out of order. The simplest comparison sort — O(n²) worst case, but with an early-termination optimisation that makes it linear on already-sorted input. Stable and in-place.

Sort integers digit by digit. Achieves linear time by exploiting digit structure instead of comparisons.

Halve the search space at each step in a sorted array. The canonical O(log n) search algorithm.

Check every element until a match is found. Works on unsorted data; baseline for search algorithm comparisons.

Find a pattern in text in linear time by never re-examining text characters — the failure (LPS) table remembers how much of the pattern already matched.

Cache overlapping subproblems to compute Fibonacci numbers in linear time instead of exponential.

Maximize value in a capacity-limited knapsack. A classic NP-hard problem solved efficiently with DP.

Find the longest subsequence common to two strings. Used in diff tools and bioinformatics.

Find the minimum number of coins that make up an amount. Classic unbounded knapsack variant.

Minimum insertions, deletions, and substitutions to transform one string into another. The classic 2D DP with traceback for the exact edit script.

A BST maintains the ordering property: left < root < right. Enables O(log n) search, insert, and delete.

A self-balancing BST that maintains O(log n) height using rotations. Guarantees worst-case log n operations.

Build an optimal prefix-free code by repeatedly merging the two least-frequent nodes. Watch the greedy tree take shape and the codes fall out.

Disjoint Set Union with path compression and union by rank. Near-constant time connectivity queries.

Insert, search, and collect prefix matches character by character. The backbone of autocomplete and spell checkers.

Range queries and point updates in O(log n) via a binary decomposition of the array. Watch queries split, recurse, and merge.

Place N queens on an N×N board so none attack each other. The canonical backtracking example — try, conflict, undo, retry.