Remember that log(n!) = log(1) + log(2) + … + log(n-1) + log(n) You can get the upper bound by log(1) + log(2) + … + log(n) <= log(n) + log(n) + … + log(n) = n*log(n) And you can get the lower bound by doing a similar thing after throwing away the first half … Read more
One way of thinking about it is this: O(N^2) means for every element, you’re doing something with every other element, such as comparing them. Bubble sort is an example of this. O(N log N) means for every element, you’re doing something that only needs to look at log N of the elements. This is usually … Read more
This question isn’t as silly as it might seem to some. At least theoretically, something such as O(1/n) is completely sensible when we take the mathematical definition of the Big O notation: Now you can easily substitute g(x) for 1/x … it’s obvious that the above definition still holds for some f. For the purpose … Read more
You model the time function to calculate Fib(n) as sum of time to calculate Fib(n-1) plus the time to calculate Fib(n-2) plus the time to add them together (O(1)). This is assuming that repeated evaluations of the same Fib(n) take the same time – i.e. no memoization is used. T(n<=1) = O(1) T(n) = T(n-1) … Read more
Since it doesn’t seem like anyone has done this before I thought it’d be good idea to have it for reference somewhere. I’ve gone though and either via benchmark or code-skimming to characterize the array_* functions. I’ve tried to put the more interesting Big-O near the top. This list is not complete. Note: All the … Read more
The time complexity, in Big O notation, for each function: int recursiveFun1(int n) { if (n <= 0) return 1; else return 1 + recursiveFun1(n-1); } This function is being called recursively n times before reaching the base case so its O(n), often called linear. int recursiveFun2(int n) { if (n <= 0) return 1; … Read more
f ∈ O(g) says, essentially For at least one choice of a constant k > 0, you can find a constant a such that the inequality 0 <= f(x) <= k g(x) holds for all x > a. Note that O(g) is the set of all functions for which this condition holds. f ∈ o(g) … Read more
Short explanation: If an algorithm is of Θ(g(n)), it means that the running time of the algorithm as n (input size) gets larger is proportional to g(n). If an algorithm is of O(g(n)), it means that the running time of the algorithm as n gets larger is at most proportional to g(n). Normally, even when … Read more
Amortised time explained in simple terms: If you do an operation say a million times, you don’t really care about the worst-case or the best-case of that operation – what you care about is how much time is taken in total when you repeat the operation a million times. So it doesn’t matter if the … Read more
I think there are several questions buried in this topic: How do you implement buildHeap so it runs in O(n) time? How do you show that buildHeap runs in O(n) time when implemented correctly? Why doesn’t that same logic work to make heap sort run in O(n) time rather than O(n log n)? How do … Read more