Find the smallest remaining item and swap it to the front. Repeat. Simple, at most n − 1 swaps, but always O(n²) comparisons.

• ✗Swapping inside the inner loop every time a smaller item is found. Swap once, after the inner loop.
• ✗Starting the inner loop at j = i instead of j = i + 1 (compares an item with itself).
• ✗Claiming selection sort has an O(n) best case. It has none; it always scans.

Compare neighbours and swap them if they are out of order. After each pass the biggest remaining item has "bubbled" to the end.

• ✗Looping j up to n - 1 in every pass instead of n - 1 - i. It still works, but does useless comparisons.
• ✗Writing a[j] >= a[j+1]. Swapping equal items breaks stability.
• ✗Reading past the array with j < n and then accessing a[j + 1].

Grow a sorted part on the left by inserting each new item into its correct place, like sorting cards in your hand. Fast on nearly sorted data.

• ✗Writing a[j] >= key in the while loop. That breaks stability.
• ✗Forgetting j >= 0 in the loop condition, which reads a[-1].
• ✗Putting a[j + 1] = key inside the while loop. It goes after the loop.

When records are big, don't move them. Sort an array of pointers (or indices) to the records instead, and only small addresses get swapped.

• ✗Swapping the records (swap(*p[i], *p[min])) instead of the pointers (swap(p[i], p[min])). That defeats the purpose.
• ✗Comparing the pointers themselves (p[j] < p[min]) instead of what they point to (p[j]->score).
• ✗Forgetting to initialise p[i] = &s[i] before sorting.

Check every item from left to right until you find the key or run out. Works on any array, sorted or not, but costs O(n).

• ✗Returning -1 inside the loop (in an else), which stops after checking only the first item.
• ✗Looping with i <= n, one past the end.
• ✗Forgetting that an unsorted array cannot use binary search.

On a sorted array, check the middle, then throw away the half that cannot contain the key. Each step halves the problem, so it takes O(log n).

• ✗Using while (low < high) instead of low <= high. That misses a key when one item is left.
• ✗Setting low = mid or high = mid instead of mid ± 1, which can loop forever.
• ✗Running it on unsorted data. The result is meaningless.

A function that calls itself on a smaller problem until it reaches a base case. You need this for trees (Ch 6) and merge/quick sort (Ch 8).

• ✗No base case, or a base case that is never reached (e.g. factorial(n + 1)).
• ✗Forgetting to return the recursive call's result (bs(...) instead of return bs(...)).
• ✗Thinking recursion is always slower or always better. It trades stack memory for simpler code.