我看到一个算法的上限是O(1/n):

由于程序外部的原因(可能是硬件的原因，也可能是处理器中的其他核心的原因)，有大量的输入正在发生变化，你必须选择一个随机但有效的输入。

现在，如果它没有变化，你可以简单地列出一个项目列表，随机选择一个，然后得到O(1)次。然而，数据的动态性质使我们无法列出列表，您只能随机探测并测试探测的有效性。(请注意，从本质上讲，不能保证返回时答案仍然有效。这仍然是有用处的——比如游戏中的单位AI。它可以射击在扣动扳机时从视线中消失的目标。)

它的最差情况性能为无穷大，但平均情况性能随着数据空间的填满而下降。

不，这不可能:

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

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

Void nothing() {};

甚至这也是有争议的!

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

我猜小于O(1)是不可能的。算法所花费的任何时间都称为O(1)。但是对于O(1/n)下面的函数呢。(我知道这个解决方案中已经出现了许多变体，但我猜它们都有一些缺陷(不是主要的，它们很好地解释了这个概念)。这里有一个，只是为了方便讨论:

def 1_by_n(n, C = 10):   #n could be float. C could be any positive number
  if n <= 0.0:           #If input is actually 0, infinite loop.
    while True:
      sleep(1)           #or pass
    return               #This line is not needed and is unreachable
  delta = 0.0001
  itr = delta
  while delta < C/n:
    itr += delta

因此，随着n的增加，函数将花费越来越少的时间。此外，如果输入实际为0，则函数将永远返回。

有人可能会说，这将受到机器精度的限制。因此，由于c eit有一个上界，它是O(1)。但我们也可以绕过它，通过在字符串中输入n和C。加法和比较是对字符串进行的。用这个方法，我们可以把n减小到任意小。因此，即使忽略n = 0，函数的上限也是无界的。

我也相信我们不能说运行时间是O(1/n)。我们应该写成O(1 + 1/n)

这是一个简单的O(1/n)算法。它甚至做了一些有趣的事情!

function foo(list input) {
  int m;
  double output;

  m = (1/ input.size) * max_value;  
  output = 0;
  for (int i = 0; i < m; i++)
    output+= random(0,1);

  return output;
}

O(1/n) is possible as it describes how the output of a function changes given increasing size of input. If we are using the function 1/n to describe the number of instructions a function executes then there is no requirement that the function take zero instructions for any input size. Rather, it is that for every input size, n above some threshold, the number of instructions required is bounded above by a positive constant multiplied by 1/n. As there is no actual number for which 1/n is 0, and the constant is positive, then there is no reason why the function would constrained to take 0 or fewer instructions.

O(1/n)并不小于O(1)这基本上意味着你拥有的数据越多，算法运行得越快。假设你有一个数组，如果它小于10100个元素就填充它，如果多于10100个元素就什么都不做。这个当然不是O(1/n)，而是O(-n):)太糟糕了，O大符号不允许负数。

O(1)仅仅表示“常数时间”。

当你给循环[1]添加一个早期退出时，你(在大O符号中)把一个O(1)算法变成了O(n)算法，但使它更快。

诀窍是一般情况下，常数时间算法是最好的，线性算法比指数算法好，但对于n很小的时候，指数算法可能更快。

1:假设这个例子的列表长度是静态的