该算法的时间复杂度是多少？

Question

public static void Comp(int n)
{
    int count=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            for(int k=1;k<n;k*=2)
            {
                count++;
            }
        }
    }
    System.out.println(count);
}

Does anyone knows what the time complexity is?

And what is the Big Oh()

Please can u explain this to me, step by step?

Answer 1

The time complexity is O(n^2 log n) . Why? each for-loop is a function of n . And you have to multiply by n for each for loop; except the inner loop which grows as log n. why? for each iteration k is multiplied by 2. Think of merge sort or binary search trees.

details

for the first two loops: summation of 1 from 0 to n, which is n+1 and so the first two loops give (n+1)*(n+1)= n^2+2n+1= O(n^2)

for the k loop, we have k growing as 1,2,4,8,16,32,... so that 2^k = n. Take the log of both sides and you get k=log n

Again, not clear?

So if we set m=0 , and a=2 then we get -2^n/-1 why is a=2? because that is the a value for which the series yields 2,4,8,16,...2^k

Answer 2

In theory this is O(n^2 * log(n)) .

Each of two outer loops is O(n) and the inner one is O(log(n)) , because log base 2 of n is the number of times which you have to divide n by 2 to get 1 .

Also this is a strict bound, ie the code is also Θ(n^2 * log(n))

Answer 3

Whoever gave you this problem is almost certainly looking for the answer n^2 log(n) , for reasons explained by others.

However the question doesn't really make any sense. If n > 2^30 , k will overflow, making the inner loop infinite.

Even if we treat this problem as being completely theoretical, and assume n , k and count aren't Java int s, but some theoretical integer type, the answer n^2 log n assumes that the operations ++ and *= have constant time complexity, no matter how many bits are needed to represent the integers. This assumption isn't really valid.

Update

It has been pointed out to me in the comments below that, based on the way the hardware works, it is reasonable to assume that ++ , *=2 and < all have constant time complexity, no matter how many bits are required. This invalidates the third paragraph of my answer.