First, key in d.keys() is guaranteed to give you the same value as key in d for any dict d. And the in operation on a dict, or the dict_keys object you get back from calling keys() on it (in 3.x), is not O(N), it’s O(1). There’s no real “optimization” going on; it’s just that … 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
In C++11 it is required that for any standard container the .size() operation must be complete in “constant” complexity (O(1)). (Table 96 — Container requirements). Previously in C++03 .size() should have constant complexity, but is not required (see Is std::string size() a O(1) operation?). The change in standard is introduced by n2923: Specifying the complexity … Read more
According to Python wiki: Time complexity, set is implemented as a hash table. So you can expect to lookup/insert/delete in O(1) average. Unless your hash table’s load factor is too high, then you face collisions and O(n). P.S. for some reason they claim O(n) for delete operation which looks like a mistype. P.P.S. This is … Read more
One trick for analyzing the time complexity of Euclid’s algorithm is to follow what happens over two iterations: a’, b’ := a % b, b % (a % b) Now a and b will both decrease, instead of only one, which makes the analysis easier. You can divide it into cases: Tiny A: 2a <= … Read more
O(n!) isn’t equivalent to O(n^n). It is asymptotically less than O(n^n). O(log(n!)) is equal to O(n log(n)). Here is one way to prove that: Note that by using the log rule log(mn) = log(m) + log(n) we can see that: log(n!) = log(n*(n-1)*…2*1) = log(n) + log(n-1) + … log(2) + log(1) Proof that O(log(n!)) … Read more
Yep, it’s still O(n^2), it has a smaller constant factor, but that doesn’t affect O notation.
The book Java Generics and Collections has this information (pages: 188, 211, 222, 240). List implementations: get add contains next remove(0) iterator.remove ArrayList O(1) O(1) O(n) O(1) O(n) O(n) LinkedList O(n) O(1) O(n) O(1) O(1) O(1) CopyOnWrite-ArrayList O(1) O(n) O(n) O(1) O(n) O(n) Set implementations: add contains next notes HashSet O(1) O(1) O(h/n) h is … Read more
The definition of big O is: O(f(n)) = { g | there exist N and c > 0 such that g(n) < c * f(n) for all n > N } In English, O(f(n)) is the set of all functions that have an eventual growth rate less than or equal to that of f. So … 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