Update 2: As we can see in Sort.swift, sort() now uses a “modified timsort” in Swift 5. Timsort is a … hybrid stable sorting algorithm, derived from merge sort and insertion sort … In the worst case, Timsort takes O(n log n) comparisons to sort an array of n elements. In the best case, which … Read more
Worst case should be O(n) (copying all n-1 elements to new array). A linked list would be O(1) for a single deletion. For those interested I’ve made this lazily-crafted benchmark. (Please don’t run on Windows XP/Vista). As you can see from this though, it looks fairly constant (i.e. O(1)), so who knows what they’re doing … Read more
Analyzing recursive functions (or even evaluating them) is a nontrivial task. A (in my opinion) good introduction can be found in Don Knuths Concrete Mathematics. However, let’s analyse these examples now: We define a function that gives us the time needed by a function. Let’s say that t(n) denotes the time needed by pow(x,n), i.e. … Read more
UPDATE: I liked this question so much, I just blogged it. See Strings, immutability and persistence The short answer is: O(n) is O(1) if n does not grow large. Most people extract tiny substrings from tiny strings, so how the complexity grows asymptotically is completely irrelevant. The long answer is: An immutable data structure built … Read more
Arrays Set, Check element at a particular index: O(1) Searching: O(n) if array is unsorted and O(log n) if array is sorted and something like a binary search is used, As pointed out by Aivean, there is no Delete operation available on Arrays. We can symbolically delete an element by setting it to some specific … Read more
It appears to be O(n) in V8 (chrome, node.js) at least: > var hash = {} > , c = 0; > > var s = +new Date();Object.keys(hash);console.log(+new Date() – s); 0 > for(var i=0; i<100000; i++, c++){ hash[c] = 1; } > var s = +new Date();Object.keys(hash);console.log(+new Date() – s); 26 > for(var i=0; … Read more
Also take a look at related sorts too: pigeonhole sort or counting sort, as well as radix sort as mentioned by Pukku.
There is a much better reference for the claim that average time heap insertion is O(1): the 1991 paper “Average Case Analysis of Heap Building by Repeated Insertion” by Hayward & McDiarmid. (This paper is linked in what is currently reference 4 of the Wikipedia article.) That paper in turn references a 1975 paper by … 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
Is there anything in the JavaScript guaranteeing that the values are looked up in O(1) time? No. JavaScript does not give any complexity guarantees whatsoever, except for ES6 collections. I know the access operator [] gives a seasoned programmer the impression that he’s dealing with an O(1) lookup structure Yes you are, this is a … Read more