The problem is that people are really sloppy with terminology. There are 3 important but distinct classes here: O(1) worst-case This is simple – all operations take no more than a constant amount of time in the worst case, and therefore in all cases. Accessing an element of an array is O(1) worst-case. O(1) amortized … Read more
LinkedHashMap will take more memory. Each entry in a normal HashMap just has the key and the value. Each LinkedHashMap entry has those references and references to the next and previous entries. There’s also a little bit more housekeeping to do, although that’s usually irrelevant.
During every iteration you increment i and decrement j which is equivalent to just incrementing i by 2. Therefore, total number of iterations is n^2 / 2 and that is still O(n^2).
This follows easily from a simple fact in Calculus: and we have the following inequality: Here we can conclude that S = 1 + 1/2 + … + 1/n is both Ω(log(n)) and O(log(n)), thus it is Ɵ(log(n)), the bound is actually tight.
If you’re using C++11, you have access to the <unordered_map> and <unordered_set> headers. These provide classes std::unordered_map and std::unordered_set. If you’re using C++03 with TR1, you have access to the classes std::tr1::unordered_map and std::tr1::unordered_set, using the same headers (unless you’re using GCC, in which case the headers are <tr1/unordered_map> and <tr1/unordered_set> instead). In all cases, … Read more
Generate all the permutations of a list You have n! lists, so you cannot achieve better efficiency than O(n!).
The time and space complexities are not related to each other. They are used to describe how much space/time your algorithm takes based on the input. For example when the algorithm has space complexity of: O(1) – constant – the algorithm uses a fixed (small) amount of space which doesn’t depend on the input. For … Read more
The array, effectively, is known by a memory location (a pointer). Accessing a[3] can be found in constant time, since it’s just location_of_a+3*sizeof(int). In C, you can see this directly. Remember, a[3] is the same as *(a+3) – which is a bit more clear in terms of what it’s doing (dereferencing the pointer “3 items” … Read more
Asymptotic complexity (which is what both big-O and big-Theta represent) completely ignores the constant factors involved – it’s only intended to give an indication of how running time will change as the size of the input gets larger. So it’s certainly possible that an Θ(n) algorithm can take longer than an Θ(n2) one for some … Read more
If the data you are sorting has a known distribution, I would use a Bucket Sort algorithm. You could add some extra logic to it so that you calculated the size and/or positions of the various buckets based upon properties of the distribution (ex: for Gaussian, you might have a bucket every (sigma/k) away from … Read more