Java Collections provide LinkedHashMap out of the box, which is well-suited to building caches. You probably don’t have this in Java ME, but you can grab the source code here: http://kickjava.com/src/java/util/LinkedHashMap.java.htm If you can’t just copy-paste it, looking at it should get you started implementing one for inclusion in your mobile app. The basic idea … Read more
Yes, Radix Sort and Counting Sort are O(N). They are NOT comparison-based sorts, which have been proven to have Ω(N log N) lower bound. To be precise, Radix Sort is O(kN), where k is the number of digits in the values to be sorted. Counting Sort is O(N + k), where k is the range … Read more
Using Stirling’s approximation, you get If you substitute it into $\choose{n}{n/2}$, you should eventually end up with PS. you might want to check my math before you actually use the answer 🙂
I know how to do recurrence relations for algorithms that only call itself once, but I’m not sure how to do something that calls itself multiple times in one occurrence. For example:
It turned out, I misunderstood Logn to be lesser than 1. As I asked few of my seniors i got to know this today itself, that if the value of n is large, (which it usually is, when we are considering Big O ie worst case), logn can be greater than 1. So yeah, O(1) … Read more
If you mean the angle that P1 is the vertex of then using the Law of Cosines should work: arccos((P122 + P132 – P232) / (2 * P12 * P13)) where P12 is the length of the segment from P1 to P2, calculated by sqrt((P1x – P2x)2 + (P1y – P2y)2)
Any function whose runtime has the form (log n)k is O((log n)k). This expression isn’t reducable to any other primitive function using simple transformations, and it’s fairly common to see algorithms with runtimes like O(n (log n)2). Functions with this growth rate are called polylogarithmic. By the way, typically (log n)k is written as logk n, so the above … 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
Explanation: The outer for loop should be clear; it is executed n times. Now to the inner loop. In the inner loop, you take n and always divide it by 2. So, you ask yourself: How many times can I divide n by 2? It turns out that this is O (log n). In fact, the base of log is 2, but in Big-O notation, we remove … Read more
Here’s a proof by contradiction: Let’s say that a function f(n) = n(log n)(log n). Assume that we think it’s also Θ(n log n), theta(n log n), so in other words there is an a for which f(n) <= a * n log n holds for large n. Now consider f(2^(a+1)): f(2^(a+1)) = 2^(a+1) * log(2^(a+1)) * log(2^(a+1)) = 2^(a+1) * log(2^(a+1)) * (a+1), … Read more