确定带有中断的循环的大O

Question

Given a function like this to find a prime number:

function find_the_prime(number) {
  var found = false;
  for(var i = 0; i < number; i++) {
    if(number%i == 0) {
      found = true; 
      break;
    }
  }  
  return found;
}

Without the break, the function in the best case is O(1), in the worst case is O(n) and the general case O(n).

Can you explain how the break affects big o? Does it at all?

Answer 1

Your code is O(1) for the trivial reason that it will always quit on the second loop because number%1 == 0.

If you correct your code to:

for(var i = 2; i < number; i++) {

Then it'll be O(n) for the same reason the @zmf said.

And without the break, it would more correctly be called O(n) even for the "best-case" because it still scales with the input. The smallest input isn't "best-case" or else all algorithms would be trivially best-case O(1) .

So it's O(n) without the break and O(n) with the break, but that doesn't mean it isn't obviously better and faster with the break. The big-O notation is about how an algorithm scales with the size of the input, not (necessarily) how fast it is. Sometimes an O(n) algorithm might be faster than an O(log n) algorithm for a particular input.

Answer 2

This is still O(N), even if thats the worst case, O(N) is how you'd refer to this algorithm. Its growth rate is still dependent on N.

(If you fix the bug that is)

Answer 3

Actually, funny enough, your answer is O(1). No matter what number you put in (as long as it's > 0), it'll always break at 1