The cache angle deserves the most space of anything here, because it is exactly where the textbook table stops predicting reality.

Big-O says linked-list insertion is O(1) and array insertion is O(n), so the list should win. For most sizes people actually use, the array wins anyway. The O(n) memmove runs over contiguous memory at cache-line speed and the prefetcher sees it coming; the list's O(1) insert is preceded by an O(n) traversal across nodes scattered over the heap, where every hop is a possible cache miss costing a couple of hundred cycles. Asymptotic analysis counts operations and treats them as equal cost. The machine does not.

The general lesson is worth stating outright: Big-O describes how a cost SCALES, not what it IS. Two O(n) algorithms can differ by an order of magnitude on identical input, and at the sizes most code actually runs, the constant factor is the whole answer.

If you benchmark it, the variable to sweep is element SIZE rather than count. The array's advantage narrows as elements grow, because fewer fit per cache line, and showing a reader where that crossover lands is far more useful than any single number.