如何知道方法是N还是N ^ 2

Question

I often see you guys talking about N methods and N^2 methods, which, correct me if I'm wrong, indicate how fast a method is. My question is: how do you guys know which methods are N and which are N^2? And also: are there other speed indications of methods then just N and N^2?

Answer 1

This talks abnout the complexity of an algorithm (which is an indicator of how fast it will be, yes)

In short, it tells how many "operations" (with operations being a very vague and abstract term) will be needed for a input to the method of size "N".

eg if your input is an List-type object, and you must iterate over all items in the list, the complexity is "N". (often expressed O(N) ).

if your input is an list-type object, and you need only to look at the first (or last), and the list gurantees to you that such a look at the item is O(1); your method will be O(1) - independent from the input size.

If your input is a list, and you need to compare every item to every other item the complexity will be O(N²) or O(N*log(n))

Answer 2

correct me if I'm wrong, indicate how fast a method is.

Its says how an algorithm will scale on an ideal machine. It deliberately ignores the factor involved which can mean that an O(1) could be slower than an O(N) which could be slower than an O(N^2) for your use-case. eg Arrays.sort() will use insertion sort O(N^2) for small collections (length < 47 in Java 7) in preference to quick sort O(N ln N)

In general, using lower order algorithms are a safer choice because they are less likely to break in extreme cases which you may not get a chance to test thoroughly.

Answer 3

The way to guesstimate the big-O complexity of a program is based on experience with dry-running code (running it in your mind). Some cases are dead obvious, but the most interesting ones aren't: for example, calling library methods known to be O(n) in an O(n) loop results in O(n ² ) total complexity; writing to a TreeMap in an O(n) loop results in O(nlogn) total, and so on.