Big O: How to determine runtime for a for loop incrementation based on outer for loop?

Question

I have the following algorithm and the runtime complexity is O(N^2) but I want to have a deeper understanding of it rather than just memorizing common runtimes.

What wo

Answer 1

Let T = the number of times the inner loop runs.

About half the time, when i, it runs at least array.length/2 times. So, for about array.length/2 outer iterations, the inner loop runs at least array.length/2 times, therefore:

T >= (N/2)*(N/2)
i.e.,
T >= N²/4

This is in O(N²). Also, though, for all array.length outer iterations, the inner loop runs at most array.length times, so:

T <= N*N, i.e.,
T <= N²

This is also in O(N²). Since we have upper and lower bounds on the time that are both in O(N²), we know that T is in O(N²).

NOTE: Technically we only need to upper bound to show that T is in O(N²), but we're usually looking for bounds as tight as we can get. T is actually in Ө(N²).

NOTE ALSO: there's nothing special about using halves above -- any constant proportion will do. These are the general rules in play:

1. Lower bound: If you do at least Ω(N) work at least Ω(N) times, you are doing Ω(N²) work. Ω(N)*Ω(N) = Ω(N²)

2. Upper bound: If you do at most O(N) work at most O(N) times, you are doing O(N²) work. O(N)*O(N) = O(N²)

3. And since we have both, we can use: Ω(N²) ∩ O(N²) = Ө(N²)