其余的大多数答案都将大o解释为专门关于算法的运行时间。但是因为问题没有提到它，我认为值得一提的是大o在数值分析中的另一个应用，关于误差。

Many algorithms can be O(h^p) or O(n^{-p}) depending on whether you're talking about step-size (h) or number of divisions (n). For example, in Euler's method, you look for an estimate of y(h) given that you know y(0) and dy/dx (the derivative of y). Your estimate of y(h) is more accurate the closer h is to 0. So in order to find y(x) for some arbitrary x, one takes the interval 0 to x, splits it up until n pieces, and runs Euler's method at each point, to get from y(0) to y(x/n) to y(2x/n), and so on.

欧拉方法是O(h)或O(1/n)算法，其中h通常被解释为步长n被解释为你划分一个区间的次数。

在实际数值分析应用中，由于浮点舍入误差，也可以有O(1/h)。你的间隔越小，某些算法的实现就会抵消得越多，丢失的有效数字就越多，因此在算法中传播的错误也就越多。

For Euler's method, if you are using floating points, use a small enough step and cancellation and you're adding a small number to a big number, leaving the big number unchanged. For algorithms that calculate the derivative through subtracting from each other two numbers from a function evaluated at two very close positions, approximating y'(x) with (y(x+h) - y(x) / h), in smooth functions y(x+h) gets close to y(x) resulting in large cancellation and an estimate for the derivative with fewer significant figures. This will in turn propagate to whatever algorithm you require the derivative for (e.g., a boundary value problem).

inline void O0Algorithm() {}

不，这不可能:

随着n在1/n范围内趋于无穷，我们最终得到1/(无穷)，这实际上是0。

因此，问题的大-oh类将是O(0)和一个巨大的n，但更接近常数时间和一个低n。这是不明智的，因为唯一可以在比常数时间更快的时间内完成的事情是:

Void nothing() {};

甚至这也是有争议的!

只要你执行了一个命令，你至少在O(1)，所以不，我们不能有一个O(1/n)的大哦类!

正如已经指出的，除了null函数可能的例外，不可能有O(1/n)个函数，因为所花费的时间必须接近0。

当然，有一些算法，比如康拉德定义的算法，它们至少在某种意义上应该小于O(1)

def get_faster(list):
    how_long = 1/len(list)
    sleep(how_long)

If you want to investigate these algorithms, you should either define your own asymptotic measurement, or your own notion of time. For example, in the above algorithm, I could allow the use of a number of "free" operations a set amount of times. In the above algorithm, if I define t' by excluding the time for everything but the sleep, then t'=1/n, which is O(1/n). There are probably better examples, as the asymptotic behavior is trivial. In fact, I am sure that someone out there can come up with senses that give non-trivial results.

随着人口增长，哪些问题会变得更容易?一个答案是像bittorrent这样的东西，下载速度是节点数量的逆函数。与汽车加载越多速度越慢相反，像bittorrent这样的文件共享网络连接的节点越多速度就越快。

我不懂数学，但这个概念似乎是寻找一个函数，需要更少的时间，你添加更多的输入?在这种情况下，怎么样:

def f( *args ): 
  if len(args)<1:
    args[1] = 10

当添加可选的第二个参数时，此函数会更快，因为否则必须赋值它。我意识到这不是一个方程，但维基百科页面说大o通常也应用于计算系统。