Pick an algorithm. Each one runs an instrumented implementation that records every important event, so the animation, the highlighted code line (JavaScript, Python, Java or Go) and the variable inspector always stay in sync.
Repeatedly compares adjacent elements and swaps them when they are out of order, so the largest unsorted value bubbles to the end after every pass.
Divides the array into a sorted prefix and an unsorted suffix. Each pass selects the minimum of the unsorted part and swaps it into the next position of the prefix.
Builds a sorted prefix one element at a time: the next element (the key) is lifted out, larger elements of the prefix shift one step right, and the key drops into the gap.
Checks every element from left to right until the target is found or the array ends. Works on unsorted data.
Searches a sorted array by repeatedly comparing the target with the middle element and discarding the half that cannot contain it.
Reverses an array in place with two pointers: swap the outermost pair, move both pointers inward, and stop when they meet.
Finds two indexes whose values add up to a target in one pass, storing each value's index in a hash map and looking up the complement (target − value).
Inserts a new node at a given position: walk to the node just before the position, point the new node at its successor, then re-link the predecessor to the new node.
A stack is Last-In-First-Out (LIFO): push adds to the top, pop removes from the top. A fixed capacity shows overflow (push when full) and underflow (pop when empty).
A queue is First-In-First-Out (FIFO): enqueue adds at the rear, dequeue removes from the front. This circular-array queue wraps the rear pointer around to reuse freed slots.
Recursively visits the left subtree, then the node itself, then the right subtree (Left → Root → Right). On a Binary Search Tree this produces the values in sorted order.
Explores the graph level by level using a queue. Because vertices are discovered in order of distance, BFS also finds the shortest path (fewest edges) from the start in an unweighted graph.
Goes as deep as possible along each branch before backtracking. This recursive version uses the call stack as its implicit stack.