I love this problem. It’s a classic interview question and depending on how you think about it, you’ll end up getting better and better solutions. It’s certainly possible to do this in better than O(n2) time, and I’ve listed three different ways that you can think about the problem here. Hopefully this answers your question! … Read more
Right from that very paragraph your linked to: Set objects must be implemented using [mechanisms] that, on average, provide access times that are sublinear on the number of elements in the collection. You will find the same sentence for Maps, WeakMaps and WeakSets. It looks the ECMA spec mandates that the implementations (e.g. Set.prototype.has) are … Read more
The complexity of in depends entirely on what L is. e in L will become L.__contains__(e). See this time complexity document for the complexity of several built-in types. Here is the summary for in: list – Average: O(n) set/dict – Average: O(1), Worst: O(n) The O(n) worst case for sets and dicts is very uncommon, … Read more
If you want examples of Algorithms/Group of Statements with Time complexity as given in the question, here is a small list – O(1) time Accessing Array Index (int a = ARR[5];) Inserting a node in Linked List Pushing and Poping on Stack Insertion and Removal from Queue Finding out the parent or left/right child of … Read more
Here a more mathematical way of seeing it, though not really complicated. IMO much clearer as informal ones: The question is, how many times can you divide N by 2 until you have 1? This is essentially saying, do a binary search (half the elements) until you found it. In a formula this would be … Read more
You will have to go to the formal definition of the big O (O) in order to answer this question. The definition is that f(x) belongs to O(g(x)) if and only if the limit limsupx → ∞ (f(x)/g(x)) exists i.e. is not infinity. In short this means that there exists a constant M, such that … Read more
Your sum v1 + (incident edges) + v2 + (incident edges) + …. + vn + (incident edges) can be rewritten as (v1 + v2 + … + vn) + [(incident_edges v1) + (incident_edges v2) + … + (incident_edges vn)] and the first group is O(N) while the other is O(E).
A particular feature of a HashMap is that unlike, say, balanced trees, its behavior is probabilistic. In these cases its usually most helpful to talk about complexity in terms of the probability of a worst-case event occurring would be. For a hash map, that of course is the case of a collision with respect to … Read more
There can be many reasons to prefer an algorithm with higher big O time complexity over the lower one: most of the time, lower big-O complexity is harder to achieve and requires skilled implementation, a lot of knowledge and a lot of testing. big-O hides the details about a constant: algorithm that performs in 10^5 … 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