Question

I have a quick sort algorithm and a counter that I increment every time a compare or swap is performed. Here are my results for random integer arrays of different sizes –

Array size --- number of operations

10000 --- 238393

20000 --- 511260

40000 --- 1120512

80000 --- 2370145

Edit:

I have removed the incorrect question I was asking in this post. What I am actually asking is –

What Im trying to find out is ‘do these results stack up with the theoretical complexity of quicksort (O(N*log(N)))?

Answer 1

Though you cannot get the asymptotic bound of your method by only experimenting, sometimes you can evaluate its behavior by drawing a graph of the complexities similar to your function, and looking at the behavior.

You can do it with drawing a graph of some functions y = f(n) such that f(10000) ~= g(10000) [where g is your function], and check the behavior difference.

In your example, we get the following graphs:

We can clearly see that:

1. The behavior of your results is sub quadric
2. The behavior is above linear.
3. It is very close to logarithmic behavior, but just a bit "higher".

From this, we can deduce that your algorithms is probably O(n^2) [not strict! remember, big O is not a strict bound], and also could be O(nlogn), if we deduce the difference from the O(nlogn) function is a noise.

Notes:

1. This method proves nothing about the algorithm, and particularly
   doesn’t give you any worst case [or even average case] bound.
2. This method is usually used to evaluate two algorithms, and not some pre defined functions, to check which is better for which inputs.

EDIT:

I drew all the graphs as y1(x) = f(x), y2(x) = g(x) , … because I found it easier to explain this way, but usually when you compare two algorithms [as you often actually use this method], the function is y(x) = f(x) / g(x), and you check if y(x) is staying close to 1, growing, shrinking?