大O-O（N ^ 2）或O（N ^ 2 +1）吗？

Question

I'm reading this Big O article (and some other book references) trying to figure out what changes affect my algorithm.

so given the following O(N^2) code:

bool ContainsDuplicates(String[] strings)
{
    for(int i = 0; i < strings.Length; i++)
    {
        for(int j = 0; j < strings.Length; j++)
        {
            if(i == j) // Don't compare with self
            {
                continue;
            }

            if(strings[i] == strings[j])
            {
                return true;
            }
        }
    }
    return false;
}

I made the following change:

bool ContainsDuplicates(String[] strings)
{
    for(int i = 0; i < strings.Length; i++)
    {
        for(int j = 0; j < strings.Length; j++)
        {
            if(i != j) // Don't compare with self
            {                               

                   if(strings[i] == strings[j])
                   {
                      return true;
                   }
            }
        }
    }
    return false;
}

Now both IF's are nested and 'continue' is removed. Does this algorithm really became a O(N^2 + 1) ? and why ? As far as I see the IF check was there before regardless, so initially thought it would still be a O(N^2).

Answer 1

Big O is describing how execution time grows as a chosen parameter becomes large.

In your example, if we wanted to be exact, the formula would be:

Time taken = Time(start) + Time(external loop) * N + Time (continue) * N + Time (no continue) * N^2

Which can be rewritten as

Time taken = a + b * N + c * N^2

Now, as N becomes larger and larger, it's clear that overall this will be shaped like a parabola. The order zero and order one terms become irrelevant as N grows to infinity.

Time taken (large N) ~= c * N^2

Finally, since we are interested in discussing qualitatively and not quantitatively , we simply describe the algorirhm as N^2

O(N^2) means that the algorithm will behave approximately as c * N^2 for large values of N

It is a similar concept to o(x) in calculus (with the difference that small-o is for parameters going to zero.