当您忽略恒定因素和原点附近的东西时， Big-O表示法（也称为“渐近增长”表示法）的作用是“看起来像”。我们用它来谈论事物如何扩展。
基本
用于“足够”的大投入...
f(x) ∈ O(upperbound)表示f“增长速度不超过”upperboundf(x) ∈ Ɵ(justlikethis)意思是f“完全一样生长”justlikethisf(x) ∈ Ω(lowerbound)意思是f“成长不比……慢”lowerbound
big-O表示法不关心常量因素：9x²据说该函数“完全像增长” 10x²。big-O 渐近符号也不关心非渐近的东西（“原点附近的东西”或“问题大小较小时会发生什么”）：该函数10x²被称为“完全像增长” 10x² - x + 2。
您为什么要忽略方程式的较小部分？因为当您考虑越来越大的比例时，它们变得与方程式的大部分完全相形见;；他们的贡献变得微不足道且无关紧要。（请参阅示例部分。）
换句话说，当您达到无穷大时，这全都与比率有关。如果将实际时间除以O(...)，则在大输入量的限制中将得到一个常数。直观地讲，这是有道理的：如果您可以将一个函数相乘得到另一个函数，则函数会彼此“缩放”。那是当我们说...
actualAlgorithmTime(N) ∈ O(bound(N))
e.g. "time to mergesort N elements
is O(N log(N))"
...这意味着对于“足够大”的问题大小N（如果我们忽略原点附近的东西），存在一些常数（例如2.5，完全组成），使得：
actualAlgorithmTime(N) e.g. "mergesort_duration(N) "
────────────────────── < constant ───────────────────── < 2.5
bound(N) N log(N)
常量有很多选择。通常，“最佳”选择被称为算法的“恒定因子” ...但是我们经常忽略它，就像我们忽略非最大的项（有关为什么它们通常无关紧要，请参见“恒定因子”部分）。您还可以将上面的方程式视为一个边界，说：“ 在最坏的情况下，所花费的时间永远不会比粗略地差N*log(N)，在2.5的因数内（我们不太在乎的恒定因数） ” 。
通常，O(...)它是最有用的一种，因为我们经常关心最坏的情况。如果f(x)表示诸如处理器或内存使用率之类的“坏”东西，则“ f(x) ∈ O(upperbound)”表示“ upperbound是处理器/内存使用率最坏的情况”。
应用领域
作为纯粹的数学构造，big-O表示法不限于谈论处理时间和内存。您可以使用它来讨论有意义缩放的任何事物的渐近性，例如：
- 参加
N聚会的人之间可能进行握手的次数（Ɵ(N²)具体来说N(N-1)/2，但重要的是它的缩放比例类似N²）
- 将病毒性营销视为时间的函数的预期概率人数
- 网站等待时间如何随CPU或GPU或计算机群集中的处理单元数量扩展
- CPU上的热量输出比例如何随晶体管数量，电压等的变化而消失。
- 一个算法需要运行多少时间，取决于输入大小
- 算法需要运行多少空间，取决于输入大小
例
对于上面的握手示例，房间中的每个人都与其他人握手。在该示例中，#handshakes ∈ Ɵ(N²)。为什么？
稍微备份一下：握手的次数正好是n-choose-2或N*(N-1)/2（每N个人握手N-1个其他人的握手，但是两次计数握手因此除以2）：
但是，对于非常多的人，线性项N相形见and，并且有效地使比率为0（在图表中：随着参与者数量的增加，对角线上的空框在总框上所占的比例会变小）。因此，缩放行为为order N²，或者握手次数“像N²一样增长”。
#handshakes(N)
────────────── ≈ 1/2
N²
好像图表对角线上的空白框（N *（N-1）/ 2个复选标记）甚至没有（N 2个复选标记渐近）一样。
（暂时偏离“普通英语” ：）如果您想向自己证明这一点，则可以对比率执行一些简单的代数运算，以将其分解为多个项（lim表示“考虑为的极限”，如果您忽略了该极限，则忽略它）。还没看过，只是“ N非常大”的记法）：
N²/2 - N/2 (N²)/2 N/2 1/2
lim ────────── = lim ( ────── - ─── ) = lim ─── = 1/2
N→∞ N² N→∞ N² N² N→∞ 1
┕━━━┙
this is 0 in the limit of N→∞:
graph it, or plug in a really large number for N
TL;博士：握手“的样子”的数量X 2这么多的大的值，如果我们写下的比例＃握手/ X 2，事实上，我们并不需要确切地 X 2的握手甚至不露面在十进制中任意大一会儿。
例如，对于x = 1百万，比率＃握手/x²：0.499999 ...
建立直觉
这使我们可以像...
“对于足够大的inputsize = N，无论常数因子是多少，如果我将输入大小加倍 ...
- ...我将O（N）（“线性时间”）算法花费的时间加倍。”
N →（2N）= 2（N）
- ...我将O（N²）（“二次时间”）算法花费的时间加倍（四倍）。” （例如，问题的100倍等于100²= 10000倍，那么……可能就不可持续了）
N² →（2N）²= 4（N²）
- ...我将O（N³）（“立方时间”）算法所花费的时间加倍（八倍）。” （例如，问题的100倍大需要100³= 1000000x的长久……非常不可持续）
cN³ →c（2N）³= 8（cN³）
- ...我在O（log（N））（“对数时间”）算法所花费的时间上加上固定的数量。” （便宜！）
c log（N） →c log（2N）=（c log（2））+（c log（N））=（固定数量）+（c log（N））
- ...我不会更改O（1）（“恒定时间”）算法所花费的时间。” （最便宜！）
c * 1 → c * 1
- ...“我（基本上）将O（N log（N））算法花费的时间加倍。” （相当普遍）
它小于O（N 1.000001），您可能愿意将其称为线性
- ...荒谬地增加了O（2 N）（“指数时间”）算法所花费的时间。” （您只需将问题增加一个单位就可以使时间增加一倍（或三倍，等等）。）
2 N →2 2N =（4 N）............换一种方式...... 2 N →2 N + 1 = 2 N 2 1 = 2 2 N
[对于数学上的倾向，您可以将鼠标悬停在扰流板上以找到较小的旁注]
（感谢https://stackoverflow.com/a/487292/711085）
（从技术上讲，恒定因素在一些更深奥的例子中可能会很重要，但是我在上面用语表达了一些事情（例如，在log（N）中），使它没有意义）
这些是程序员和应用程序计算机科学家用作参考的增长的基础。他们一直看到这些。（因此，尽管您可以从技术上考虑“将输入加倍会使O（√N）算法慢1.414倍”，但最好将其视为“这比对数差，但比线性差”。）
恒定因素
通常，我们不在乎特定的常数因子是什么，因为它们不会影响函数的增长方式。例如，两种算法都可能需要花费O(N)时间才能完成，但是一种算法的速度可能是另一种算法的两倍。我们通常不会太在乎，除非这个因素很大，因为优化是一项棘手的业务（优化何时过早？）；同样，仅选择具有更好的big-O的算法的动作通常也会将性能提高几个数量级。
一些渐近上乘的算法（例如，非比较O(N log(log(N)))类）可能具有如此大的常数因子（例如100000*N log(log(N))），或者开销相对较大（例如O(N log(log(N)))隐藏）+ 100*N，以至于即使在“大数据”上也很少值得使用。
为什么有时O（N）是您可以做的最好的事情，即为什么我们需要数据结构
O(N)从某种意义上讲，如果需要读取所有数据，则算法是“最佳”算法。在阅读这个行为一组数据是一个O(N)操作。通常将其加载到内存中O(N)（如果有硬件支持，则加载速度更快；如果您已经读取了数据，则加载时间将非常短）。但是，如果您触摸甚至查看每条数据（甚至每条其他数据），您的算法都将花费一些O(N)时间来执行此查找。无论您的实际算法花费多长时间，至少O(N)是因为它花费了时间查看所有数据。
写作的行为也可以这样说。所有输出N个事物的算法都将花费N个时间，因为输出至少要那么长（例如，输出所有排列（重新排列）一组N张扑克牌的因子分解：）O(N!)。
这激发了数据结构的使用：一个数据结构只需要读取一次数据（通常是O(N)时间），再加上一些我们想要保持的较小量的预处理（例如O(N)or O(N log(N))或or O(N²)）。此后，修改数据结构（插入/删除/等）并查询数据需要很少的时间，例如O(1)或O(log(N))。然后，您继续进行大量查询！通常，您愿意提前做的工作越多，以后要做的工作就越少。
例如，假设您拥有数百万条路段的纬度和经度坐标，并且想要查找所有街道交叉点。
- 朴素的方法：如果您具有街道交叉点的坐标，并且想要检查附近的街道，则每次都必须遍历数百万个路段，并检查每个路段的相邻性。
- 如果您只需要执行一次此操作，那么只需要执行一次简单的
O(N)工作方法就不会有问题，但是如果您想执行多次（在这种情况下，N每个段一次），我们必须要做的O(N²)工作，或1000000²= 1000000000000操作。不好（一台现代计算机每秒可以执行约十亿次操作）。
- 如果我们使用称为哈希表（即时速度查找表，也称为哈希图或字典）的简单结构，则通过
O(N)及时预处理所有内容，我们将付出很小的代价。此后，平均仅需花费固定时间即可通过其键查找内容（在这种情况下，我们的键是经度和纬度坐标，四舍五入为一个网格；我们搜索只有9个元素的相邻网格空间，即不变）。
- 我们的任务从不可行
O(N²)变为易于管理O(N)，而我们要做的就是支付少量费用来制作哈希表。
- 类比：在此特定情况下的类比是一个拼图游戏：我们创建了一个利用数据某些属性的数据结构。如果我们的路段像拼图一样，我们通过匹配颜色和图案将它们分组。然后，我们利用它来避免以后做额外的工作（将颜色相似的拼图相互比较，而不是将每个拼图相互比较）。
故事的寓意：数据结构使我们加快了运营速度。甚至更多的高级数据结构还可以使您以难以置信的巧妙方式组合，延迟甚至忽略操作。不同的问题会有不同的类推，但它们都涉及以一种利用我们关心的结构或为簿记而人为地施加某种结构的方式来组织数据。我们会提前进行工作（基本上是计划和组织），现在重复执行的任务要容易得多！
实际示例：在编码时可视化增长顺序
渐进符号的本质与编程完全不同。渐近符号是一种思考事物如何缩放并可以在许多不同领域中使用的数学框架。就是说...这就是将渐近符号应用于编码的方式。
基础知识：每当我们与大小为A的集合中的每个元素进行交互（例如数组，集合，映射的所有键等），或执行循环A的迭代时，即大小A的乘法因子。为什么说“乘法因子”？–因为循环和函数（几乎是按定义）具有乘法运行时间：迭代次数，循环中完成的工作时间（或对于函数：调用次数）功能，乘以在该功能中完成的工作）。（这很普遍，如果我们不做任何花哨的事情，例如跳过循环或尽早退出循环，或者基于参数更改函数中的控制流，这是很常见的。）这是一些可视化技术示例，带有伪代码。
（在这里，xs代表工作的恒定时间单位，处理器指令，解释器操作码等）
for(i=0; i<A; i++) // A * ...
some O(1) operation // 1
--> A*1 --> O(A) time
visualization:
|<------ A ------->|
1 2 3 4 5 x x ... x
other languages, multiplying orders of growth:
javascript, O(A) time and space
someListOfSizeA.map((x,i) => [x,i])
python, O(rows*cols) time and space
[[r*c for c in range(cols)] for r in range(rows)]
范例2：
for every x in listOfSizeA: // A * (...
some O(1) operation // 1
some O(B) operation // B
for every y in listOfSizeC: // C * (...
some O(1) operation // 1))
--> O(A*(1 + B + C))
O(A*(B+C)) (1 is dwarfed)
visualization:
|<------ A ------->|
1 x x x x x x ... x
2 x x x x x x ... x ^
3 x x x x x x ... x |
4 x x x x x x ... x |
5 x x x x x x ... x B <-- A*B
x x x x x x x ... x |
................... |
x x x x x x x ... x v
x x x x x x x ... x ^
x x x x x x x ... x |
x x x x x x x ... x |
x x x x x x x ... x C <-- A*C
x x x x x x x ... x |
................... |
x x x x x x x ... x v
范例3：
function nSquaredFunction(n) {
total = 0
for i in 1..n: // N *
for j in 1..n: // N *
total += i*k // 1
return total
}
// O(n^2)
function nCubedFunction(a) {
for i in 1..n: // A *
print(nSquaredFunction(a)) // A^2
}
// O(a^3)
如果我们做一些稍微复杂的事情，您可能仍然可以在视觉上想象发生了什么：
for x in range(A):
for y in range(1..x):
simpleOperation(x*y)
x x x x x x x x x x |
x x x x x x x x x |
x x x x x x x x |
x x x x x x x |
x x x x x x |
x x x x x |
x x x x |
x x x |
x x |
x___________________|
在这里，您可以绘制的最小的可识别轮廓很重要。三角形是二维形状（0.5 A ^ 2），就像正方形是二维形状（A ^ 2）一样；这里的两个常数因子仍然是两者之间的渐近比，但是，我们像所有因子一样都忽略了它……（这种技术有些不幸的细微之处，我不会在这里讨论；它可能会误导您。）
当然，这并不意味着循环和功能不好。相反，它们是现代编程语言的基础，我们喜欢它们。但是，我们可以看到，将循环，函数和条件与我们的数据（控制流等）结合在一起的方式模仿了程序的时间和空间使用！如果时间和空间的使用成为问题，那就是当我们诉诸机灵并找到我们未曾考虑过的简单算法或数据结构时，以某种方式降低增长的顺序。但是，这些可视化技术（尽管它们并不总是有效）可以在最坏的运行时间为您提供幼稚的猜测。
这是我们可以从视觉上识别的另一件事：
<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x
x x x x x x x x
x x x x
x x
x
我们可以重新排列一下，看看它是O（N）：
<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x|x x x x x x x x|x x x x|x x|x
或者也许您对数据进行log（N）次传递，总时间为O（N * log（N））：
<----------------------------- N ----------------------------->
^ x x x x x x x x x x x x x x x x|x x x x x x x x x x x x x x x x
| x x x x x x x x|x x x x x x x x|x x x x x x x x|x x x x x x x x
lgN x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x
| x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x
v x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x
不相关但值得再次提及：如果我们执行哈希（例如字典/哈希表查找），则这是O（1）的因数。那太快了。
[myDictionary.has(x) for x in listOfSizeA]
\----- O(1) ------/
--> A*1 --> O(A)
如果我们执行非常复杂的操作（例如使用递归函数或分治算法），则可以使用主定理（通常有效），或者在荒谬的情况下，可以通过Akra-Bazzi定理（几乎总是有效）来查找您的算法在Wikipedia上的运行时间。
但是，程序员并不这样认为，因为最终，算法直觉只是第二天性。您将开始编写效率低下的代码，然后立即想到“我在做效率低下的事情吗？ ”。如果答案是“是”，并且您认为它确实很重要，那么您可以退后一步，想出各种使事情运行更快的技巧（答案几乎总是“使用哈希表”，很少使用“使用树”，很少有更复杂的东西）。
摊销和平均情况下的复杂性
还有“摊销”和/或“平均情况”的概念（请注意，它们是不同的）。
平均情况：这仅是对函数的期望值使用big-O表示法，而不是对函数本身使用。在通常情况下，您认为所有输入的可能性均等，平均情况只是运行时间的平均值。例如，对于quicksort，即使最坏的情况是O(N^2)针对某些真正糟糕的输入，但通常情况还是很常见O(N log(N))（真正的糟糕输入的数量非常少，因此很少有人在平均情况下不会注意到它们）。
摊销最坏情况：某些数据结构可能具有最坏情况的复杂性，但是要保证，如果您执行许多此类操作，则平均工作量将比最坏情况要好。例如，您可能具有通常需要固定O(1)时间的数据结构。但是，偶尔它会“打cup”并花一些O(N)时间进行一次随机操作，因为它可能需要做一些簿记或垃圾收集之类的工作……但是它向您保证，如果打h了，它不会再打N N更多操作。最坏情况下的成本仍然是O(N)每次操作，但许多运行的摊销成本为O(N)/N=O(1)每个操作。由于大型操作非常少见，因此可以将大量的临时工作与其他工作融合为一个恒定因素。我们说该作品在足够多的通话中被“摊销”，以至于渐渐消失。
摊销分析的类比：
你开汽车。有时，您需要花费10分钟去加油站，然后花费1分钟为储罐加气。如果您每次开车去任何地方都这样做（花10分钟车程到加油站，花几秒钟填充一加仑的油），这将是非常低效的。但是，如果您每隔几天就给油箱加油一次，那么开车到加油站所花费的11分钟便会在足够多的行程中“摊销”，您可以忽略它，并假装所有行程可能要长5％。
平均情况与摊销最坏情况之间的比较：
- 平均情况：我们对输入进行一些假设；即，如果我们的输入具有不同的概率，那么我们的输出/运行时将具有不同的概率（我们取其平均值）。通常，我们假设所有输入的可能性均等（均等概率），但是如果实际输入不符合我们对“平均输入”的假设，则平均输出/运行时计算可能没有意义。但是，如果您期望统一的随机输入，则可以考虑一下！
- 摊销后的最坏情况：如果使用摊销后的最坏情况数据结构，则性能可以保证在摊销后的最坏情况之内...最终（即使输入是由知道所有情况并试图搞砸了）。通常，我们用它来分析那些性能可能非常“不稳定”且出现意外大打algorithms的算法，但是随着时间的推移，它们的性能将与其他算法一样好。（但是，除非您的数据结构对其愿意拖延的许多出色工作有上限，否则邪恶的攻击者可能会强迫您一次全部追赶最大的拖延工作量。
不过，如果您合理地担心攻击者，那么除摊销和平均情况外，还有许多其他算法攻击媒介值得担心。）
平均用例和摊销都是在考虑和考虑比例时非常有用的工具。
（如果对此子主题感兴趣，请参阅平均案例与摊销分析之间的差异。）
多维big-O
大多数时候，人们没有意识到工作中存在多个变量。例如，在字符串搜索算法中，您的算法可能会花费一些时间O([length of text] + [length of query])，即它在两个变量（例如）中是线性的O(N+M)。其他更幼稚的算法可能是O([length of text]*[length of query])或O(N*M)。忽略多个变量是我在算法分析中看到的最常见的疏漏之一，在设计算法时可能会给您带来麻烦。
整个故事
请记住，大O并不是全部。您可以通过使用缓存来大大加快某些算法的速度，使它们可以忽略缓存，通过使用RAM而不是磁盘，使用并行化或提前进行工作来避免瓶颈-这些技术通常与增长顺序无关。尽管您经常会在并行算法的big-O表示法中看到内核数，但是使用“ big-O”表示法。
还要记住，由于程序的隐藏约束，您可能并不真正在意渐近行为。您可能正在使用有限数量的值，例如：
- 如果您要对5种元素进行排序，则您不希望使用快速的
O(N log(N))快速排序。您想使用插入排序，而插入排序恰好在较小的输入上表现良好。这些情况通常在分而治之的算法中出现，您可以将问题分解为越来越小的子问题，例如递归排序，快速傅立叶变换或矩阵乘法。
- 如果由于某些隐藏的事实而使某些值有效地受到限制（例如，一般的人名柔和地限制在40个字母左右，而人的年龄则柔和地限制在150个左右）。您还可以在输入上加上界限，以有效地使术语保持不变。
实际上，即使在具有相同或相似渐近性能的算法中，它们的相对价值实际上也可能受其他因素驱动，例如：其他性能因素（quicksort和mergesort都是两者O(N log(N))，而quicksort 利用CPU缓存）；非性能方面的考虑因素，例如易于实施；库是否可用以及库的信誉和维护程度。
程序在500MHz计算机上的运行速度也将比2GHz计算机上的运行慢。我们实际上并不认为这是资源范围的一部分，因为我们考虑的是机器资源（例如，每个时钟周期）而不是每秒的扩展。但是，有些类似的事情会“秘密地”影响性能，例如您是否在仿真下运行，或者编译器是否优化了代码。这些可能会使一些基本操作花费更长的时间（甚至相对于彼此），甚至可能渐近地（甚至相对于彼此）加快或减慢某些操作。在不同的实现和/或环境之间，效果可能很小或很大。您是否切换语言或机器以节省一点额外的工作？这取决于其他一百个原因（必要性，技能，同事，程序员的生产力，
上述问题，就像选择哪种编程语言的效果一样，几乎永远不会被视为恒定因素的一部分（也不应该）。但人们应该意识到它们，因为有时（尽管很少）它们可能会影响事物。例如，在cpython中，本机优先级队列实现不是渐近最优的（O(log(N))而不是O(1)您选择的插入或find-min）；您是否使用其他实现？可能不是，因为C的实现可能更快，并且其他地方可能还有其他类似的问题。需要权衡；有时它们很重要，有时却不重要。
（编辑：“普通英语”的解释到此结束。）
数学附录
为了完整起见，big-O表示法的精确定义如下：f(x) ∈ O(g(x))表示“ f渐近地由const * g上限”：忽略x的某个有限值以下的所有内容，存在一个常数使得|f(x)| ≤ const * |g(x)|。（其他符号如下：与O均值≤，Ω均值≥一样。有小写变体：o均值<和ω均值>。）均f(x) ∈ Ɵ(g(x))表示f(x) ∈ O(g(x))和并且f(x) ∈ Ω(g(x))（由g上下限制）：存在一些常数，使得f将始终位于const1*g(x)和之间的“范围”内const2*g(x)。这是您可以做出的最强渐近陈述，大致相当于==。（对不起，为了清晰起见，我选择将绝对值符号的描述推迟到现在；尤其是因为我从未见过在计算机科学环境中出现负值的情况。）
人们会经常使用= O(...)，这也许是更正确的“ comp-sci”符号，并且完全合法使用；读为“ f = O（...）”，“ f是阶... / f由... xxx包围”，并且被认为是“ f是渐近性为...的某些表达式”。有人教我使用更严格的方法∈ O(...)。∈表示“是……的元素”（仍然像以前一样阅读）。在这种特殊情况下，O(N²)包含像{元素2 N²，3 N²，1/2 N²，2 N² + log(N)，- N² + N^1.9，...}是无限大的，但它仍然是一个集合。
O和Ω不对称（n = O（n²），但n²不是O（n）），但是Ɵ是对称的，并且（因为这些关系都是传递和自反的）Ɵ因此是对称的，传递和自反的，因此将所有函数的集合划分为等效类。等效类是我们认为相同的一组事物。也就是说，给定您可以想到的任何功能，您都可以找到该类的规范/唯一的“渐近代表”（通常采用极限值...我认为）；就像您可以将所有整数分组为偶数或偶数一样，您可以将所有带有all的函数分组为x-ish，log（x）^ 2-ish等，通过基本忽略较小的术语（但有时您可能会陷入困境）更复杂的功能，它们本身就是单独的类）。
该=符号可能是更常见的一种，甚至被世界著名的计算机科学家用在论文中。另外，通常情况下，在随意的环境中，人们会说出O(...)他们的意思Ɵ(...)；从技术上讲这是正确的，因为事物Ɵ(exactlyThis)集是O(noGreaterThanThis)... 的子集，并且更容易键入。;-)
