这个特定函数的时间复杂度\\ big（O）是多少？

Question

What is the time comlexity of this function(f1)?

as I can see that the first loop(i=0)-> (n/4 times) the second one(i=3)->(n/4 - 3 times).... etc, the result is: (n/3)*(n/4 + (n-3)/4 + (n-6)/4 + (n-9)/4 ....

And I stop here, how to continue?

int f1(int n){
  int s=0;
  for(int i=0; i<n; i+=3)
    for (int j=n; j>i; j-=4)
      s+=j+i;
  return s;
}

Answer 1

The important thing about Big(O) notation is that it eliminates 'constants'. The objective is to determine trend as input size grows without concern for specific numbers.

Think of it as determining the curve on a graph where you don't know the number ranges of the x and y axes.

So in your code, even though you skip most of the values in the range of n for each iteration of each loop, this is done at a constant rate. So regardless of how many you actually skip, this still scales relative to n^2 .

It wouldn't matter if you calculated any of the following:

1/4 * n^2
0.0000001 * n^2
(1/4 * n)^2
(0.0000001 * n)^2
1000000 + n^2
n^2 + 10000000 * n

In Big O, these are all equivalent to O(n^2) . The point being that once n gets big enough (whatever that may be), all the lower order terms and constant factors become irrelevant in the 'big picture'.

( It's worth emphasising that this is why on small inputs you should be wary of relying too heavily on Big O. That's when constant overheads can still have a big impact. )

Answer 2

Key observation: The inner loop executes (ni)/4 times in step i , hence i/4 in step ni .

Now sum all these quantities for i = 3k, 3(k-1), 3(k-2), ..., 9, 6, 3, 0 , where 3k is the largest multiple of 3 before n (ie, 3k <= n < 3(k+1) ):

3k/4 + 3(k-1)/4 + ... + 6/4 + 3/4 + 0/4 = 3/4(k + (k-1) + ... + 2 + 1)
                                        = 3/4(k(k+1))/2
                                        = O(k^2)
                                        = O(n^2)

because k <= n/3 <= k+1 and therefore k^2 <= n^2/9 <= (k+1)^2 <= 4k^2

Answer 3

In theory it's "O(n*n)", but...

What if the compiler felt like optimising it into this:

int f1(int n){
  int s=0;
  for(int i=0; i<n; i+=3)
    s += table[i];
  return s;
}

Or even this:

int f1(int n){
  if(n <= 0) return 0;
  return table[n];
}

Then it could also be "O(n)" or "O(1)".

Note that on the surface these kinds of optimisations seem impractical (due to worst case memory costs); but with a sufficiently advanced compiler (eg using "whole program optimisation" to examine all callers and determine that n is always within a certain range) it's not inconceivable. In a similar way it's not impossible for all of the callers to be using a constant (eg where a sufficiently advanced compiler can replace things like x = f1(123); with x = constant_calculated_at_compile_time ).

In other words; in practice, the time complexity of the original function depends on how the function is used and how good/bad the compiler is.