计算函数的复杂度，在python中为hw

Question

I need to calculate the running time complexity of the function in terms of n (for exmaple O(n)), n is len(lst) , lst is a variable of list type.

this is what I thought, is it right? (I need to find the most tight bound!!!)

Answer 1

Ok, it's a pretty complex problem, and quite an enjoyable one for a homework.

First it is obvious that you have to split the problem into two parts, either if n is larger than 100 000 or not.

If n is larger than 100 000:

You will run the innermost loop maximum 20 000 times at once (because when j gets larger than 100 000, your k loop will result in 0 iterations). So for every simulation, for the part of n above 50 000 you will exactly perform

total loops. It gives

. You have to add the time of the calculation of the i < 50 000 (n < 100 000) part, which can be written as

,

that gives .

It means that above n = 100 000, your problem has a clear O(n) complexity with a constant part one or more magnitudes smaller than the linear one:

The tricky part arrives when you get below n = 100 000. Here you can write

,

which can be transformed into:

This function shows a linear increase with a squared decrease. Guess where its root is… (almost) exactly at 100 000.

Calculating the sum and leaving the O(1), O(n) and non-significant parts you get:

.

You can see that its cubic part is negative, so the time would go below 0 for large ns. But you can also see that at n = 100 000, the squared part is still three times bigger than the cubic one, and the maximum of the function is at n = 200 000. So don't worry, you won't go into negative times, in fact, you won't even reach the maximum of this function.

How can you interpret this? Well, in worst case, you have O(n2) complexity. But you have a higher order decrease, and for large ns below 100 000, you can do much (max. 33%) better than the O(n2) would predict.

So to sum up:

• If n is much smaller than 100 000: O(n2)
• If n is close, but smaller than 100 000: somewhat better than O(n2)
• If n is larger than 100 000: O(n)

I ran an example to measure what's going on. I used different numbers (because your original problem would run forever), so your 100 000 threshold value is at 100 in my case. You can see that in the beginning, O(n2) works fine, then O(n2-n3) fits well the complexity, finally, above 100, we enter the linear part.

And for large ns (still with a threshold of 100):