BigOCheatSheet

Actually, the page you referred to is highly misleading - even if not completely wrong. If you analyze the complexity of an algorithm, you first have to specify the scenario: i.e. whether you are talking about worst-case (the default case), average case or best-case. For each of the three scenarios, you can then give a lower bound (Ω), upper bound (O) or a tight bound (Θ).

Take insertion sort as an example. While the page is, strictly speaking, correct in that the best case is Ω(n), it could just as well (and more precisely) have said that the best case is Θ(n). Similarly, the worst case is indeed O(n²) as stated on that page (as well as Ω(n²) or Ω(n) or O(n³)), but more precisely it's Θ(n²).

Using Ω to always denote the best case and O to always denote the worst-case is, unfortunately, an often made mistake. Takeaway message: the scenario (worst, average, best) and the type of the bound (upper, lower, tight) are two independent dimensions.

As per the chart, I believe what they are trying to imply access is to access an specific element (1st , 2nd or ith element) thats why hash table has N/A. you cant access elements by order in hash table.

Let's look at your attempt to write insertion sort:

You're right that 2n, 4n and 8n are all just O(n), and you're also right that O(1.6ⁿ) is not the same as O(2ⁿ). To understand why, we need to refer to the definition of big O notation.

The notation O(...) means a set of functions. A function f(n) is in the set O(g(n)) if and only if, for some constants c and n₀, we have f(n) ≤ c * g(n) whenever n ≥ n₀. Given this definition:

• The function f(n) = 8n is in the set O(n) because if we choose c = 8 and n₀ = 1, we have 8n ≤ 8 * n for all n ≥ 1.
• The function f(n) = 2ⁿ is not in the set O(1.6ⁿ), because whichever c and n₀ we choose, 2ⁿ > c * 1.6ⁿ for some sufficiently large n. We can choose n > log₂ c + n₀ log₂ 1.6 for a concrete counterexample.
• Note however that f(n) = 1.6ⁿ is in the set O(2ⁿ), because 1.6ⁿ ≤ 1 * 2ⁿ for all n ≥ 1.

For a "catch-all" way of writing exponential complexity, you can write 2^O(n). This includes exponential functions with arbitrary bases, e.g. the function f(n) = 16ⁿ since this equals 2⁴ⁿ, and 4n is in the set O(n). It's an abuse of notation, since raising the number 2 to the power of a set of functions doesn't really make sense in this context, but it is common enough to be understood.

Assuming that Calculate the force the bodies apply to one another is an O(1) operation then what you have is the following summation.

The answer to your question is: yes.

Typically, when the O(1) time complexity is stated for insertion or deletion in a linked list, it is assumed that a pointer to the node in question is already known. This isn't totally useless, however. Consider the case where you want to traverse a list and remove elements matching a certain description. With a linked list, this can be done in O(n) time with O(1) additional space. With an array, this would typically require O(n^2) time or O(n) additional space.

You’re correct; the cost of a lookup in a splay tree can reach Θ(n) for an imbalanced tree.

Many resources like the big-O cheat sheet either make simplifying assumptions or just have factually incorrect data in them. It’s unclear whether they were just wrong here, or whether they were talking amortized worst case, etc.

It’s always best to know the internals of the data structures you’re working with so that you can understand where the runtimes come from.

Generally when doing Big-O analysis, we ignore constant time operations (i.e. O(1)) and any constant factors. We are just trying to get a sense of how well the algorithm scales with N. What this means in practice is that we are looking for loops and non-constant time operations

With that in mind, I've copied your code below and then annotated certain points of interest.