algo.viz

Repeatedly steps through the list, compares adjacent elements and swaps them if they're in the wrong order. The largest values "bubble up" to the end each pass.

Builds a sorted portion one element at a time by taking each new element and inserting it into its correct position in the already-sorted left portion.

Recursively divides the array in half, sorts each half, then merges them back together. Guaranteed O(n log n) but requires extra memory for merging.

Picks a pivot element and partitions the array around it so elements less than pivot go left, greater go right. Recursively sorts each partition in place.

Builds a max-heap from the array, then repeatedly extracts the maximum to build the sorted result. Combines good worst-case guarantees with in-place operation.

Explores all neighbors at the current depth before moving deeper. Guarantees the shortest path in an unweighted graph. Uses a queue (FIFO).

Dives as deep as possible along each branch before backtracking. Does not guarantee shortest path. Uses a stack (LIFO) — naturally recursive.

Finds the shortest path in a weighted graph. Uses a priority queue to always expand the currently cheapest node. On an unweighted grid it behaves like BFS.

Extends Dijkstra with a heuristic function h(n) estimating distance to the goal. f(n) = g(n) + h(n). With Manhattan distance heuristic it's optimally efficient on grids.

Each node has at most two children. Left subtree contains only nodes with values less than the parent; right subtree only greater values. Supports O(log n) search, insert, and delete on average.