Is the time complexity of the empty algorithm O(0)?

Question

So given the following program:

---

Is the time complexity of this program O(0)? In other words, is 0 O(0)?

I thought answering this in a separate question

Answer 1

It should be O(1). The coefficient is always 1.

Consider:

If something grows like 5n, you don't say O(5n), you say O(n) [in other words, O(1n)]

If something grows like 7n^2, you don't say O(7n^2), you say O(n^2) [in other words, O(1n^2)]

Likewise you should say O(1), not O(some other constant)

Answer 2

From Wikipedia:

A description of a function in terms of big O notation usually only provides an upper bound on the growth rate of the function.

From this description, since the empty algorithm requires 0 time to execute, it has an upper bound performance of O(0). This means, it's also O(1), which happens to be a larger upper bound.

Edit:

More formally from CLR (1ed, pg 26):

For a given function g(n), we denote O(g(n)) the set of functions

O(g(n)) = { f(n): there exist positive constants c and n₀ such that 0 ≤ f(n) ≤ cg(n) for all n ≥ n₀ }

The asymptotic time performance of the empty algorithm, executing in 0 time regardless of the input, is therefore a member of O(0).

Edit 2:

We all agree that 0 is O(1). The question is, is 0 O(0) as well?

Based on the definitions, I say yes.

Furthermore, I think there's a bit more significance to the question than many answers indicate. By itself the empty algorithm is probably meaningless. However, whenever a non-trivial algorithm is specified, the empty algorithm could be thought of as lying between consecutive steps of the algorithm being specified as well as before and after the algorithm steps. It's nice to know that "nothingness" does not impact the algorithm's asymptotic time performance.

Edit 3:

Adam Crume makes the following claim:

For any function f(x), f(x) is in O(f(x)).

Proof: let S be a subset of R and T be a subset of R^* (the non-negative real numbers) and let f(x):S ->T and c ≥ 1. Then 0 ≤ f(x) ≤ f(x) which leads to 0 ≤ f(x) ≤ cf(x) for all x∈S. Therefore f(x) ∈ O(f(x)).

Specifically, if f(x) = 0 then f(x) ∈ O(0).

Answer 3

O(1) means the algorithm's time complexity is always constant.

Let's say we have this algorithm (in C):

void doSomething(int[] n)
{
  int x = n[0]; // This line is accessing an array position, so it is time consuming.
  int y = n[1]; // Same here.
  return x + y;
}

I am ignoring the fact that the array could have less than 2 positions, just to keep it simple.

If we count the 2 most expensive lines, we have a total time of 2.

2 = O(1), because:

2 <= c * 1, if c = 2, for every n > 1

If we have this code:

public void doNothing(){}

And we count it as having 0 expansive lines, there is no difference in saying it has O(0) O(1), or O(1000), because for every one of these functions, we can prove the same theorem.

Normally, if the algorithm takes a constant number of steps to complete, we say it has O(1) time complexity.

I guess this is just a convention, because you could use any constant number to represent the function inside the O().

Answer 4

Given the formal definition of Big O:

Let f(x) and g(x) be two functions defined over the set of real numbers. Then, we write:

f(x) = O(g(x)) as x approaches infinity iff there exists a real M and a real x0 so that:

|f(x)| <= M * |g(x)| for every x > x0

As I see it, if we substitute g(x) = 0 (in order to have a program with complexity O(0)), we must have:

|f(x)| <= 0, for every x > x0 (the constraint of existence of a real M and x0 is practically lifted here)

which can only be true when f(x) = 0.

So I would say that not only the empty program is O(0), but it is the only one for which that holds. Intuitively, this should've been true since O(1) encompasses all algorithms that require a constant number of steps regardless of the size of its task, including 0. It's essentially useless to talk about O(0); it's already in O(1). I suspect it's purely out of simplicity of definition that we use O(1), where it could as well be O(c) or something similar.

Answer 5

I have a very simple argument for the empty algorithm being O(0): For any function f(x), f(x) is in O(f(x)). Simply let f(x)=0, and we have that 0 (the runtime of the empty algorithm) is in O(0).

On a side note, I hate it when people write f(x) = O(g(x)), when it should be f(x) ∈ O(g(x)).

Answer 6

All of the answers so far address the question as if there is a right and a wrong answer. But there isn't. The question is a matter of definition. Usually in complexity theory the time cost is an integer --- although that too is just a definition. You're free to say that the empty algorithm that quits immediately takes 0 time steps or 1 time step. It's an abstract question because time complexity is an abstract definition. In the real world, you don't even have time steps, you have continuous physical time; it may be true that one CPU has clock cycles, but a parallel computer could easily have asynchronoous clocks and in any case a clock cycle is extremely small.

That said, I would say that it's more reasonable to say that the halt operation takes 1 time step rather than that it takes 0 time steps. It does seem more realistic. For many situations it's arguably very conservative, because the overhead of initialization is typically far greater than executing one arithmetic or logical operation. Giving the empty algorithm 0 time steps would only be reasonable to model, for example, a function call that is deleted by an optimizing compiler that knows that the function won't do anything.