See algorithms think.

Repeatedly steps through the list, compares adjacent pairs and swaps them if they are out of order.

Scans the unsorted suffix for its smallest element and swaps it to the front.

Grows a sorted prefix one element at a time: each new key is shifted left past every larger element until it reaches its place.

An insertion sort over interleaved sub-arrays: elements gap apart are sorted first, then the gap shrinks until it is 1.

Bottom-up merge sort: runs of width 1, 2, 4, … are merged pairwise into an auxiliary buffer and copied back, doubling the sorted run length each pass.

Picks the last element as a pivot and partitions the range so smaller elements land to its left (Lomuto scheme); the pivot is then in its final place and both sides are sorted recursively.

Arranges the array as a binary max-heap, then repeatedly swaps the root (the maximum) to the end and sifts the new root down to restore the heap.

Never compares elements: it tallies how often each value occurs, turns the tally into prefix sums (each value's end position), then places every element straight into the output.

Sorts by one decimal digit at a time, least significant first, using a stable counting sort for each digit.

Checks every element from left to right until it finds the target or runs out of array.

On a sorted array, compares the target with the middle of the remaining range and throws away the half that cannot contain it.

On a sorted array, jumps ahead √n elements at a time until it overshoots the target, then scans that one block linearly.

A contiguous block of slots with a size and a capacity.

Each node stores a value and a pointer to the next node, so inserting or deleting rewires a pointer or two instead of shifting elements.

Every node links both to its successor and its predecessor, and the list keeps a tail pointer.

Last in, first out: push adds on top and pop takes from the top, both in O(1).

First in, first out: enqueue joins at the rear and dequeue leaves from the front.

Maps each key to one of m buckets with hash(k) = k mod m and keeps colliding keys in a chain.

Every key in a node's left subtree is smaller and every key in its right subtree is larger, so search, insert and delete each follow one root-to-leaf path.

A self-balancing BST: every node's subtrees differ in height by at most one.

A complete binary tree stored in an array where every parent is ≤ its children, so the minimum is always at the root.

A prefix tree: each edge is a letter and each path from the root spells a prefix, so words that share a prefix share nodes.

Breadth-first search spreads out from the start one ring at a time using a FIFO queue, so cells are reached in order of their distance in moves.

Depth-first search keeps going in one direction (up first, then right, down and left) and only backtracks to the most recent unexplored cell on its stack when it hits a dead end.

Dijkstra's algorithm always expands the open cell with the smallest known distance, so on a weighted grid it finds the cheapest path rather than the one with fewest moves.

A* is Dijkstra's algorithm steered by a heuristic: it expands the cell with the smallest f = g + h, where g is the cost so far and h is the Manhattan distance still to go.

Breadth-first search visits the source, then all of its neighbours, then their unseen neighbours, using a FIFO queue.

Depth-first search follows one branch as deep as it can before backing up to the most recent node that still has an unexplored neighbour.

Dijkstra's algorithm grows a set of settled nodes outward from the source, always settling the unfinished node with the smallest tentative distance and then relaxing its edges.

Kahn's algorithm orders a directed acyclic graph so every edge points forward: it repeatedly outputs a node with no remaining incoming edges and deletes that node's outgoing edges.

Prim's algorithm grows a minimum spanning tree from a single node, each round adding the cheapest edge that connects the tree to a node outside it.

Kruskal's algorithm considers edges from lightest to heaviest and keeps each one that joins two different components, skipping any edge that would close a cycle.

Computes F(n) bottom-up: write down the base cases F(0) = 0 and F(1) = 1, then fill each cell as the sum of the two before it.

Finds the longest sequence of letters that appears in both strings in the same order, not necessarily side by side.

Picks the subset of items with the highest total value whose total weight fits the capacity, where each item is either taken whole or left behind.

Counts the fewest single-letter inserts, deletes and substitutions that turn one string into another (Levenshtein distance).