algoviz.xyz

Bidirectional bubble sort that traverses in both directions.

Repeatedly swaps adjacent elements until the array is sorted.

Divides the array in half, sorts each half, then merges them back together.

Three-way partitioning algorithm to sort elements into three groups.

Builds a max heap and repeatedly extracts the maximum element.

Randomly shuffles elements until the array happens to be sorted.

Partitions around a pivot element and recursively sorts sub-arrays.

Each element sleeps for a time proportional to its value, then reports in.

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

Moves elements to correct position like a garden gnome sorting flower pots.

Waits for a miracle (cosmic rays) to sort the array.

Finds the minimum element and places it at the beginning of the unsorted portion.

Sorts integers by processing individual digits from least to most significant.

Removes elements that are out of order — the survivors are sorted.

Places N queens on an N×N chessboard so no two queens threaten each other.

Solves a Sudoku puzzle using backtracking and constraint propagation.

Sudoku solver using Minimum Remaining Values and Least Constraining Value heuristics.

Finds a path for a knight to visit every square on the chessboard exactly once.

Moves a tower of disks from one peg to another using recursive strategy.

Generates all possible orderings of a set of elements.

Generates all valid combinations of balanced parentheses.

Finds all valid words in a grid of letters using DFS backtracking.

Visualizes Breadth-First Search pathfinding on a grid with obstacles.

Visualizes Depth-First Search pathfinding on a grid with obstacles.

Finds the minimum cost tree connecting all vertices using Kruskal's algorithm.

Orders vertices in a directed acyclic graph so every edge goes from earlier to later.

Fills a connected region of a grid starting from a seed point using a stack-based approach.

Counts connected components (islands) in a 2D grid using flood fill.

Visits the root first, then recursively traverses left and right subtrees.

Recursively traverses the left subtree, visits the root, then the right subtree.

Recursively traverses left and right subtrees, then visits the root last.

Visits all nodes level by level from top to bottom using a queue (BFS).

Side-by-side comparison of preorder, inorder, postorder, and level-order traversals.

Visualizes min-heap operations including insertions and extractions.

Builds a trie (prefix tree) by inserting words one character at a time.

Searches for a word in a trie by traversing character-by-character.

Reverses a singly linked list by re-pointing node references.

Merges two sorted linked lists into one sorted list.

Efficiently finds a target value by halving the search space each step.

Searches a sorted array using Fibonacci numbers to narrow the range.

Outputs true only when all inputs are true.

Outputs true when at least one input is true.

Inverts the input — outputs true when the input is false.

Outputs true when inputs differ (exclusive or).

Outputs false only when all inputs are true (negated AND).

Outputs true only when all inputs are false (negated OR).

Outputs true when inputs are the same (negated XOR).

Builds Pascal's triangle row by row, showing how each entry is the sum of the two above.

Finds all prime numbers up to a limit by eliminating multiples.

Estimates the value of pi by randomly sampling points inside a unit square.

Approximates definite integrals by randomly sampling points under a curve.

Cellular automaton where cells live, die, or reproduce based on simple rules.