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
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
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
Bellman-Ford algorithm is a single-source shortest path algorithm, so when you have negative edge weight then it can detect negative cycles in a graph. The only difference between the two is that Bellman-Ford is also capable of handling negative weights whereas Dijkstra Algorithm can only handle positives. From wiki However, Dijkstra’s algorithm greedily selects the … Read more
Usually nowadays I see It used to be common to see It all gets the point across.
n log(n) implies that the algorithm looks at all N items log(n) times. But that’s not what’s happening with Quickselect. Let’s say you’re using Quickselect to pick the top 8 items in a list of 128. And by some miracle of random selection, the pivots you pick are always at the halfway point. On the … Read more