The common growth rates run from O(1) at the cheap end to O(n!) at the expensive end. Each class in this list costs more than the one above it as input grows:
O(1) constant: same cost always, like a hash lookup.
O(log n) logarithmic: binary search on sorted data.
O(n) linear: one scan through the data.
O(n log n) linearithmic: the best general sorting.
O(n^2) quadratic: comparing every pair.
O(2^n) exponential: trying every subset.
O(n!) factorial: trying every ordering.
"Fastest" here means it grows slowest, so it stays cheap at scale.
At a thousand items, linear is a thousand steps while quadratic is a million. Anything exponential or factorial becomes unusable past small inputs, so spotting it early saves you from a program that never finishes.
Rewriting in plainer words…
This answer doesn't lend itself to a diagram - it reads best . No credits were charged.
Where would O(sqrt n) and O(n^3) fit in that list?A strong answer places each one by comparing how fast it grows, and notes that any polynomial grows slower than any exponential.
From cheapest to most expensive, the common classes are O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n) and O(n!).
Constant time is something like a hash lookup, and log n is binary search on sorted data.
Linear is one pass over the data, n log n is what the best general sorts cost, and quadratic usually means comparing every pair.
Exponential means trying every subset, and factorial means trying every ordering.
When I say fastest, I mean the cost grows slowest. At a thousand items, linear is a thousand steps while quadratic is a million.
Exponential and factorial become unusable past small inputs, so I try to spot them early, before I end up with a program that never finishes.
Weak answers to avoid
Reverses the order or misreads fastestFastest here means the cost grows slowest. Say up front that O(1) is cheapest and O(n!) is the most expensive, so nobody reads the ranking backwards.
Recites the list with no examplesA memorized list proves little. Tie each class to a pattern, such as binary search for log n or comparing every pair for n^2, to show you can spot it in code.
Misplaces n log n or swaps 2^n and n!n log n sits between linear and quadratic, and n! grows faster than 2^n. Getting the middle or the end of the list wrong suggests you memorized it without understanding it.
Treats Big-O as exact runtimeBig-O ranks growth, not wall-clock time. For small n, constants can let a quadratic method beat an n log n one, so say the ranking holds as n grows.
Interview lens
Likely follow-ups, what you can say, and the weak answers to avoid.
