big-O表示法中以下函数的时间复杂度是多少？

Question

I'm working on understanding big O and I have run into a tricky problem.

When I look at this code, I immediately think O(n) just by looking at the for loop but the line

result = result * k

makes me think it is something different.

if power(int n, int k)
{
    int result = n
    for (int i = 1; i < n; i++){
        result = result * k
    }
}

Just looking for some clear explanation on why I may or may not be wrong

Answer 1

This is not a tricky problem unless you're using a language like C++ that permits operator overloading and the operator*() method of types of k or result is overloaded, or else there is a standalone (free) overloaded operator method defined with those types as its arguments. I'm assuming this is not the case, so:

Your loop is of order O(n). Within that loop, what do you do? Do you do another loop? Or call a method that does so? No. Is your system's multiply operator complexity based on the size of its operands? Perhaps technically yes, since a 32-bit multiply will be faster on a 32-bit core than a 64-bit multiply, but that's based on the types of the operands, not on the operands' values. Multiply operations are normally of order O(1).

So the overall complexity is O(n*1), or just O(n).

The only way this is anything other than O(n) is if the multiply operator is overloaded, and implemented in a naive way; eg if it does the integer multiplication by iterating k times and adding result to itself k times. In that case , the overall complexity would be O(n ² ).

But in any normal case the complexity is just O(n).

Answer 2

This is only a statement, this is not about group of statements that iterations not dependent on n. So we know about this result = result * k this is in O (1) in any case its time complexity can't change. time complexity of your code is O (n) not more than O (n)