我更喜欢尽可能少的正式定义和简单的数学。
大O只是一种方式来“表达”自己,以一种常见的方式,“运行我的代码需要多少时间/空间?”
因此,你可能明白“n2”是什么意思,但要更具体,玩你的想法,你有一个简单的,最简单的分类算法;泡沫分类。
我的名单
比较 1 和 6 是最大的? Ok 6 是正确的位置,前进! 比较 6 和 3, oh, 3 是更少的! 让我们移动, Ok 列表改变了,我们需要从现在开始!
為每個項目,你再看所有項目一次,為比較,這也是“n”,所以為每個項目,你看“n”時刻意味著n*n = n2
我希望这就像你想要的那样简单。
EDIT:快注,这几乎是令人困惑的Big O评分(这是一个上线)与Theta评分(这是一个上线和下线)。在我的经验中,这实际上是非学术设置讨论的典型。
在一个句子中:随着你的工作的规模上升,完成工作需要多长时间?
“大O”评分的一个重要方面是,它不会说哪个算法会更快到一个特定的尺寸。 采取一个字符串(字符串,整体值)对一系列对(字符串,整体值)。 是否更快地找到字符串中的关键或字符串中的元素,基于字符串? (即字符串, “找到字符串部分与特定的关键相匹配的第一个元素” ) 字符串是基因。
最简单的定义我可以给大 Oh 评分是:
智者可能已经意识到,我们可以表达操作的数量如:n2 + 2n. 但是,正如你从我们的例子中看到的两个数字的百万数字左右,第二个术语(2n)变得毫无意义(计算为0.0002%的总操作在这个阶段)。
因此,要找到一个名字给了电话号码(逆转搜索):
最佳案例:O(1);预期案例:O(n)(为500,000);最糟糕案例:O(n)(为1000,000)。
旅行卖家
听起来很简单吗?再想一想。
聚合物时间
另一个我想快速提到的是,任何具有O(na)复杂性的算法都说具有多元复杂性,或者在多元时间可溶解。
大 O 是算法使用时间/空间的尺寸,与其输入的尺寸相比。
如果一个算法是O(n),那么时间/空间将与其输入相同的速度增加。
如果一个算法是O(n2)则时间/空间增加以其输入的速度为方形。
等等等。
大 O 描述了一个功能的增长行为上限,例如一个程序的运行时间,当输入变得大。
例子:
O(n):如果我翻倍输入大小,运行时间将翻倍O(n2):如果输入大小将翻倍运行时间四倍O(log n):如果输入大小翻倍运行时间将增加一倍O(2n):如果输入大小增加一倍,运行时间将翻倍
输入尺寸通常是比特所需的空间来代表输入。
O(n2):被称为四方复杂性
1 件: 1 件 10 件: 100 件 100 件: 10,000 件
请注意,物品的数量增加了10个因素,但时间增加了102个因素。
O(n):被称为线性复杂性
1 件: 1 操作 10 件: 10 操作 100 件: 100 操作
这一次,元素的数量增加了10个因素,所以时间n=10,所以O(n)的规模因素是10。
O(1):被称为恒久复杂性
1 件: 1 操作 10 件: 2 操作 100 件: 3 操作 1000 件: 4 操作 10,000 件: 5 操作
他们降低了数学,所以它可能不是准确的n2或他们说它是什么,但这将是规模的支配因素。
它切断到骨头,只提供关于算法的规模性质的信息,具体如何使用资源(思考时间或记忆)的算法规模,以回应“输入大小”。
考虑蒸汽发动机和火箭之间的差异. 它们不仅仅是相同的东西的不同品种(如说,一个Prius发动机与一个Lamborghini发动机),但它们是显著不同的类型的驱动系统,在它们的核心。
大 O 评分是描述一个算法的空间或运行时间的上限的一种方式. n 是问题的元素数量(即序列的尺寸,树上的节点数量等) 我们有兴趣描述运行时间,因为 n 变得大。
要说二进制搜索有运行时间的O(登录)是说有某些恒定的c,你可以增加登录(n)通过它将总是比运行时间的二进制搜索。
换句话说,g(n)是你的算法的运行时间,我们说g(n) = O(f(n))当g(n) <=c*f(n)当n > k,当c和k是某些恒定的。
actualAlgorithmTime(N) ∈ O(bound(N))
e.g. "time to mergesort N elements
is O(N log(N))"
actualAlgorithmTime(N) e.g. "mergesort_duration(N) "
────────────────────── < constant ───────────────────── < 2.5
bound(N) N log(N)
#handshakes(N)
────────────── ≈ 1/2
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
这让我们做出这样的陈述......
我把时间的倍增到一个O(N)(“线性时间”)算法所需要的时间。
某些无形上级的算法(例如,非比较的O(N log(N))类型)可能具有如此大的恒定的因素(例如,100000*N log(N))),或相对较大的顶部,如O(N log(N))与隐藏的+100*N,它们很少值得使用,即使在“大数据”。
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)]
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___________________|
<----------------------------- 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
<----------------------------- 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
<----------------------------- 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
[myDictionary.has(x) for x in listOfSizeA]
\----- O(1) ------/
--> A*1 --> O(A)
混合和中型案例复杂性
(请参见中间案例和折扣分析之间的差异,如果您对此主题感兴趣。
数学 Addenda
Big-O 是由程序所消耗的资源增加率,即问题例大小。
资源:可能是CPU时间,可能是最大 RAM 空间。
说问题是“找到金额”,
int Sum(int*arr,int size){
int sum=0;
while(size-->0)
sum+=arr[size];
return sum;
}
problem-instance= {5,10,15} ==> problem-instance-size = 3, iterations-in-loop= 3
problem-instance= {5,10,15,20,25} ==> problem-instance-size = 5 iterations-in-loop = 5
说问题是“找到组合”,
void Combination(int*arr,int size)
{ int outer=size,inner=size;
while(outer -->0) {
inner=size;
while(inner -->0)
cout<<arr[outer]<<"-"<<arr[inner]<<endl;
}
}
problem-instance= {5,10,15} ==> problem-instance-size = 3, total-iterations = 3*3 = 9
problem-instance= {5,10,15,20,25} ==> problem-instance-size = 5, total-iterations= 5*5 = 25
对于“n”尺寸的输入,该程序以序列中的“n*n”节点的速度生长,因此,Big-O是N2以O(n2)表达。
大 O 评分最常被编程者用作计算(算法)将需要多长时间完成的约定测量,表达为输入组的尺寸的函数。
在许多情况下,一个算法的“O”将落入下列情况之一:
O(1) - 完成时间是相同的,无论输入组的尺寸. 一个例子是通过指数访问一个序列元素. O(Log N) - 完成时间增加大约与 log2(n)相匹配。 例如, 1024 个元素需要大约两倍的长度为 32 个元素,因为 Log2(1024) = 10 和 Log2(32) = 5. 一个例子是找到一个元素在二进制搜索树(BST)。
大 O 忽略了没有有意义的因素,因为输入尺寸向无限增加,而函数的增长曲线,这意味着由函数添加或加倍的恒数只是被忽略。
我不确定我正在进一步贡献这个主题,但我仍然认为我会分享:我曾经发现这个博客帖子有几个非常有用的(也许非常基本的)解释和例子关于Big O:
通过例子,这有助于在我的<unk>子像<unk>子一样的喉<unk>中获得细微的基本,所以我认为这是一个相当下载10分钟的阅读,让你走在正确的方向。
什么是清晰的英语解释大O? 尽可能少的正式定义和简单的数学。
一个简单的英语解释需要Big-O评分:
当我们编程时,我们试图解决一个问题. 我们编码的称为算法. 大 O 评级允许我们以标准的方式比较我们算法的最糟糕的案例性能. 硬件特征随着时间的推移而变化,硬件的改进可以减少运行算法需要的时间。
英文片名 What Big O Notation 是:
不是所有的算法运行相同的时间,并且可以根据输入中的项目数量而变化,我们将称之为n. 基于这一点,我们将考虑最糟糕的案例分析,或者运行时间的上限,因为n 变得更大和更大。
f(x) = k(x)g(x) k 与 a(如果 a = +∞,这意味着有 N 和 M 等数,以至于每个 x > N 的, < M 等数。
sin x = O(x) when x → 0. sin x = O(1) when x → +∞, x2 + x = O(x) when x → 0, x2 + x = O(x2) when x → +∞, ln(x) = o(x) = O(x) when x → +∞。
更多例子
算法例(Java):
public boolean search(/* for */Integer K,/* in */List</* of */Integer> L)
{
for(/* each */Integer i:/* in */L)
{
if(i == K)
{
return true;
}
}
return false;
}
算法描述:
这个算法搜索一个列表,项目按项目,寻找一个密钥,在列表中的每个项目,如果它是密钥,然后返回真实,如果循环没有找到密钥,返回虚假。
Big-O 评分代表了复杂性(时间、空间等)的顶端。
要找到 The Big-O on Time Complexity:
计算时间(考虑到输入大小)最糟糕的案例需要: 最糟糕的案例: 关键不在列表中 时间(Worst-Case) = 4n+1 时间: O(4n+1) = O(n) <unk>在大O,恒例被忽视 O(n) ~ 线性
还有大欧米加,它代表了最佳案例的复杂性:
最佳案例:关键是第一个项目 时间(最佳案例) = 4 时间: Ω(4) = O(1) ~ Instant\Constant
测量软件程序的速度非常困难,当我们尝试时,答案可以非常复杂,并且充满了例外和特殊案例,这是一个很大的问题,因为所有这些例外和特殊案例都令人沮丧和无助,当我们想比较两个不同的程序,以确定哪个是“最快”。
好事:
邪恶的:
和那可怕的:
“什么是明确的英语解释大O?尽可能少的正式定义和简单的数学。
这样一个美丽简单而短暂的问题似乎至少值得一个同样短暂的答案,就像一个学生在教学期间可以得到的那样。
大 O 评级简单地说明一个算法可以运行多长时间,仅仅是输入数据的数量。
(在一个美妙的,无单位的时间感中!)(这就是重要,因为人们总是想要更多,无论他们生活在今天还是明天)
好吧,什么是那么奇妙的关于大O评级,如果这就是它做什么?
实际上,Big O分析是如此有用和重要,因为Big O把重点放在算法本身的复杂性上,完全忽略了一切只是比例性恒定的东西 - 如JavaScript引擎,CPU的速度,您的互联网连接,以及所有快速变成像模型T一样可笑的过时的东西。
假设我们正在谈论一个算法A,该算法应该做一些与数据集的尺寸n。
然后 O( <某些表达式 X 涉及 n> ) 意思,在简单的英语:
如果您在执行 A 时不幸,可能需要尽可能多的 X(n) 操作完成。
正如发生的那样,有某些功能(想想它们作为X(n))的实施,这些功能往往很常见,这些功能是众所周知的,易于比较的(例子:1、Log N、N、N^2、N!等)。
比较这些,当谈到A和其他算法时,很容易根据他们可能需要完成的操作数量排序算法。
总的来说,我们的目标将是找到或结构一个算法A,以便它有一个函数X(n)返回尽可能低的数字。
一个简单的答案可以是:
大 O 代表了这个算法可能最糟糕的时间/空间. 算法永远不会超过这个限制的空间/时间. 大 O 代表了极端情况下的时间/空间复杂性。
1(一) :
这种复杂性与O(1)相同,除非它只是稍微糟糕一点,对于所有实用目的,你可以把它视为一个非常大的连续规模。
和(n):
O(n log n):
O(n2):
它作为一个平方,在那里 n 是平方侧的长度. 这是与“网络效应”相同的增长率,在那里网络中的每个人都可以知道网络中的每个人. 增长是昂贵的. 大多数可扩展的解决方案不能使用这个复杂度的算法,而不做显著的体操。
二(二) :
大 O 评级是描述算法将运行多快的方式,因为有意数量的输入参数,我们将称之为“n”。在计算机科学中是有用的,因为不同的机器以不同的速度运行,简单地说算法需要 5 秒,不会告诉你很多,因为虽然你可能运行一个系统与 4.5 GHz 八核处理器,我可能运行一个系统。
statement;
是持久的. 声明的运行时间不会与 N 相比变化
for ( i = 0; i < N; i++ )
statement;
for ( i = 0; i < N; i++ )
{
for ( j = 0; j < N; j++ )
statement;
}
是四角形的,两条路的运行时间相当于N的平面,当N翻倍时,运行时间增加为N * N。
while ( low <= high )
{
mid = ( low + high ) / 2;
if ( target < list[mid] )
high = mid - 1;
else if ( target > list[mid] )
low = mid + 1;
else break;
}
算法的运行时间是相当于 N 可以分为 2 次的次数。
void quicksort ( int list[], int left, int right )
{
int pivot = partition ( list, left, right );
quicksort ( list, left, pivot - 1 );
quicksort ( list, pivot + 1, right );
}
是 N * log ( N ). 运行时间由 N 轮子(以色列或重复)组成,它们是 logarithmic,因此算法是线性和 logarithmic 的组合。
一般来说,做某些东西与每个项目在一个维度是线性的,做某些东西与每个项目在两个维度是四方的,并将工作区域分成一半是逻辑的。 还有其他大 O 测量,如圆形,曝光,和平方根,但它们不被报告为常见。 大 O 评分被描述为 O( )在哪里是测量。
查看更多: 这里
如果你有一个合适的概念的无限在你的头脑,那么有一个非常简短的描述:
大 O 评级告诉你解决一个无限大的问题的成本。
此外,
常见因素不可忽视
如果你升级到一个可以运行你的算法的计算机两倍的速度,大 O 评级不会注意到这一点. 持续的因素改进太小,甚至在大 O 评级工作的规模中也会注意到。
然而,任何“大”比恒定的因素都可以被检测到。
如果上面的没有意义,那么你头脑中没有相容的直观的无限观念,你可能应该忽略上面的所有观念;我唯一知道如何使这些观念严格,或者解释它们是否已经是直观的有用,就是先教你大O评分或类似的东西。
如果我想向6岁的孩子解释这一点,我会开始绘制一些函数f(x) = x 和f(x) = x^2 例如,并问一个孩子哪个函数将是页面顶部的顶部函数。
上述说法是一个很好的开始,但不是完全真实的。
更准确的解释(数学)
n = 输入参数数
T(n) = 表达算法运行时间的实际函数为 n 的函数
c = 常态
f(n)= 表达算法运行时间为 n 的函数的约定函数
接下来,在大O方面,接近f(n)被认为足够好,只要下面的条件是真实的。
lim T(n) ≤ c×f(n)
n→∞
方程式是如 n 接近无限, T 的 n 是少于或等于 c 次 f 的 n。
T(n)∈O(n)
回到英语
基于上面的数学定义,如果你说你的算法是一个大O的n,这意味着它是一个函数的n(输入参数的数量)或更快。
Big O of n 意味着我的算法运行至少如此之快. 你不能看你的算法的 Big O 评分,并说它很慢. 你只能说它很快。
这是一个非常简单的解释,但我希望它涵盖了最重要的细节。
让我们说你的算法处理问题取决于某些“因素”,例如,让我们做它N和X。
根据 N 和 X,您的算法将需要一些操作,例如在 WORST 案例中,它是 3(N^2) + log(X) 操作。
由于Big-O不太关心恒定的因素(aka 3),你的算法的Big-O是O(N^2 + log(X))。它基本上翻译“你的算法需要最糟糕的案例规模的操作数量”。
告诉你从亚马逊订购哈利·波特:完整的8电影收藏(Blu-ray)并同时在线下载相同的电影收藏。你想测试哪种方法更快。
从实验中,我们知道在线购物的规模比在线下载更好,很重要的是要了解大O评级,因为它有助于分析算法的规模性和效率。
注意: 大 O 评级是算法最糟糕的场景,假设 O(1) 和 O(n) 是上面的例子最糟糕的场景。
参考: http://carlcheo.com/compsci
这里来了大O,告诉我们这个数学是多么艰难。
现在他们要求我添加一个到十个!为什么我会这样做?我不想添加一个到六个?添加一个到十个......好......这会更难!
对于大 n 而言, n 平方比 n 更大。
一个:我选择一张卡在我们现在工作的地板部分,你可以为我选择一个,如果你愿意(第一次我们这样做,“我们现在工作的地板部分”是整个地板,当然。
大 O 告诉我们:这个类型需要 O(n log n) 工作完成,在中间情况下。
现在你知道我的朋友,大O,他帮助我们做不到工作,如果你知道大O,你也可以做不到工作!
你和我一起学到了这一切!你太聪明了!谢谢你!
现在这个工作已经完成了,让我们玩吧!
大 O 在平式英语是如<=(少于或等)。当我们说为两个函数f 和 g,f = O(g) 它意味着f <= g。
但是,这并不意味着任何 n f(n) <= g(n) 事实上,它意味着 f 是增长方面低于或等于 g 的,这意味着在一个点 f(n) <= c*g(n) 之后,如果 c 是恒定的,然后一个点意味着所有 n >= n0 在那里 n0 是另一个恒定的。
大 O 是一种代表任何函数的顶部界限的手段,我们通常使用它来表达一个函数的顶部界限,说明一个算法的运行时间。
Ex : f(n) = 2(n^2) +3n 是代表假设算法的运行时间的函数,Big-O 评级基本上给了这个函数的上限,即 O(n^2)。
这个评级基本上告诉我们,对于任何输入“n”的运行时间不会超过Big-O评级所表达的值。
此外,同意上述所有详细答案,希望这有助于!!!
大 O 描述一类功能。
它描述了大输入值的快速功能的增长方式。
对于一个特定的函数f,O(f)分解了所有函数g(n),您可以找到一个n0和一个恒定的c,以便与n>=n0的g(n)的所有值都低于或相当于c*f(n)。
在较少的数学词语中,O(f)是一组函数,即所有函数,从某些值 n0 向前,增长缓慢或像 f 一样快。
如果 f(n) = n 那么
g(n) = 3n 是 O(f) 。 因为恒定的因素不重要 h(n) = n+1000 是 O(f) 因为它可能比所有值小于 1000 但对于大 O 只有大输入物质。
然而,i(n) = n^2不在O(f)中,因为一个四方函数比一个线性函数增长得更快。
我找到了一个非常好的解释关于大O评分,特别是对于一个没有太多的数学的人。
https://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/
在计算机科学中使用Big O评分来描述算法的性能或复杂性。Big O具体描述了最糟糕的情况,并且可以用来描述一个算法所需的执行时间或使用的空间(例如在内存或磁盘上)。
预告片
算法:解决问题的程序/公式
如何分析算法,如何比较算法?
例如:你和一个朋友被要求创建一个函数,将数字从 0 到 N. 你与 f(x) 和你的朋友与 g(x) 相同的结果,但两个函数有不同的算法。
Big-O 评分:描述运行时间将与输入相对增长的速度,因为输入随意大。
三个关键点:
比较运行时间的增长速度 不要比较准确的运行时间(取决于硬件) 只关心运行时间的增长与输入(n) 因为n 随意大,专注于将增长最快的术语,因为n 得到大(想想无限) AKA 无形分析
空间复杂性:除了时间复杂性之外,我们也关心空间复杂性(一个算法使用的内存/空间多少)。
我最喜欢的英语词来描述这个概念是你为一个任务付出的代价,因为它越来越大。
既然这些常态在长期内并不重要,这种语言允许我们讨论超越我们正在运行的基础设施之外的任务,所以工厂可以到任何地方,工人可以到任何地方 - 它都是可怕的,但是工厂的大小和工人的数量是我们在长期内可以改变的事情,因为您的输入和输出增长。
由于时间和空间是经济量(即它们是有限的)在这里,它们都可以用这个语言表达。
技术笔记: 时间复杂性的一些例子 - O(n) 一般意味着如果一个问题是“n”的大小,我至少必须看到一切。 O(log n) 一般意味着我减半问题的大小,检查并重复,直到任务完成。
什么是“大O”笔记的明确英语解释?
在“大O”中,意思是“命令”(或准确地说“命令”),所以你可以从字面上得到它的想法,它是用来命令一些东西来比较它们。
“大O”做两件事:估计你的计算机适用于完成一个任务的方法的步骤多少。 方便这个过程与其他人进行比较,以确定它是否好? “大O”通过标准化评分实现上述两件事。 有七个最常用的评分O(1),这意味着你的计算机得到一个任务完成1步,这是很好的, 订单 No.1 O(logN), 平均值
此分類上一篇
请注意订单在线结束,只是为了更好地理解。有超过7个评分,如果所有可能性考虑。
概述“大O”描述算法的性能,并评估它;或者正式处理它,“大O”分类算法并标准化比较过程。
TLDR:Big O在数学术语中解释算法的性能。
较慢的算法倾向于在 n 运行到 x 或多个,取决于它的深度,而更快的,如二进制搜索运行在 O(log n),这使得它运行更快,因为数据集变得更大。
可以从算法中最复杂的线路计算大O看。
有了小型或未分类的数据集,Big O 可能令人惊讶,因为 n log n 复杂性算法如二进制搜索可以缓慢较小的或未分类的集,为一个简单的运行例子线性搜索与二进制搜索,请参见我的JavaScript例子:
https://codepen.io/serdarsenay/pen/XELWqN?editors=1011(下面的算法)
function lineerSearch() {
init();
var t = timer('lineerSearch benchmark');
var input = this.event.target.value;
for(var i = 0;i<unsortedhaystack.length - 1;i++) {
if (unsortedhaystack[i] === input) {
document.getElementById('result').innerHTML = 'result is... "' + unsortedhaystack[i] + '", on index: ' + i + ' of the unsorted array. Found' + ' within ' + i + ' iterations';
console.log(document.getElementById('result').innerHTML);
t.stop();
return unsortedhaystack[i];
}
}
}
function binarySearch () {
init();
sortHaystack();
var t = timer('binarySearch benchmark');
var firstIndex = 0;
var lastIndex = haystack.length-1;
var input = this.event.target.value;
//currently point in the half of the array
var currentIndex = (haystack.length-1)/2 | 0;
var iterations = 0;
while (firstIndex <= lastIndex) {
currentIndex = (firstIndex + lastIndex)/2 | 0;
iterations++;
if (haystack[currentIndex] < input) {
firstIndex = currentIndex + 1;
//console.log(currentIndex + " added, fI:"+firstIndex+", lI: "+lastIndex);
} else if (haystack[currentIndex] > input) {
lastIndex = currentIndex - 1;
//console.log(currentIndex + " substracted, fI:"+firstIndex+", lI: "+lastIndex);
} else {
document.getElementById('result').innerHTML = 'result is... "' + haystack[currentIndex] + '", on index: ' + currentIndex + ' of the sorted array. Found' + ' within ' + iterations + ' iterations';
console.log(document.getElementById('result').innerHTML);
t.stop();
return true;
}
}
}
定义 : 大 O 评级是指如果数据输入增加,算法性能将如何表现的评级。
当我们谈论算法时,有3个重要柱子 算法输入、输出和处理 大 O 是象征性的评分,如果数据输入增加到什么速度,算法处理的性能将有所不同。
例如,请参见下面的函数“函数1”,该函数收集并在第一个记录中进行处理,现在该函数的性能将是相同的,无论您放置1000、10万或100000记录。
void Function1(List<string> data)
{
string str = data[0];
}
void Function2(List<string> data)
{
foreach(string str in data)
{
if (str == "shiv")
{
return;
}
}
}
因此,通过查看Big O评级,我们分类算法的好和坏区域。
此分類上一篇
https://www.youtube.com/watch?v=k6kxtzICG_g
什么是“大O”笔记的明确英语解释?
我想强调“大O”评分的驱动动力是一件事,当算法的输入尺寸变得太大时,算法的某些部分(即恒数、比例、术语)的方程式描述算法的尺寸变得如此无意义,以至于我们忽略它们。
因此,如果输入尺寸不太大,那么“大O”评分(上限)的想法将毫无意义。
Lets say you want to quantify the performance of the following algorithm
int sumArray (int[] nums){
int sum=0; // here we've 1 operation
for(int i=0; i < nums.length;i++){ // we've n times
sum += nums[i]; // taking initialization and assignments, 3 ops
}
return sum;
}
在上面的算法中,让我们说你发现T(n)如下(时间复杂性):
T(n) = 3*n + 2
n= 1,000,000 -> T(1,000,000) = 3,000,002
n=1,000,000,000 -> T(1,000,000,000) = 3,000,000,002
n=10,000,000,000 -> T(10,000,000,000) = 30,000,000,002
将此类输入给另一个函数 F(n) = n
n= 1,000,000 -> F(1,000,000) = 1,000,000
n=1,000,000,000 -> F(1,000,000,000) = 1,000,000,000
n=10,000,000,000 -> F(10,000,000,000) = 10,000,000,000
因为你可以看到输入尺寸变得太大,T(n)大约相当于或接近F(n),所以连续2和比例3变得太不重要,现在大O“评级的想法来了,
O(T(n)) = F(n)
O(T(n)) = n
要做一个字面类似,你不关心跑者能跑到100米,甚至跑到5K的速度,你更关心马拉松人,最好是超级马拉松人(除此之外,跑的类似性会崩溃,你必须转向“长跑”的形象意义)。
关于所有这些数学逻辑和多元化是什么? 显然算法与这些数学术语内在相关。 如果你测量区块上的所有孩子的高度,它会花费你那么多时间,因为有孩子。 这是内在相关的 n^1 或只是 n 的概念,在那里 n 是区块上的孩子数量。
我希望我已经解释说,大O的评级仅仅是关于长期,数学与计算方式有内在的联系,数学术语和其他简化与长期有相当常见的联系。
有几个很棒的答案已经发布,但我希望以不同的方式做出贡献. 如果你想看到发生的一切,你可以假设一个编辑器可以在 ~1sec 中完成近10^8操作. 如果输入在10^8中,你可能想设计一个算法,以线性方式运作(如一个不需要运行)。
此分類上一篇
当我们有一个函数,如f(n) = n+3 和我们想知道图表看起来如何喜欢,当n接近无限时,我们只是放下所有的连续和较低的顺序术语,因为它们不在乎什么时候n变得大。
常规和较低的命令时间的简单落下,正是找到下方和上方的功能的过程。
根据定义,一个函数是另一个函数的下层或上层界限,如果您可以找到一个恒定的函数,以便为每个 n 的输出比原始函数更大(或较小)。
f(n) = n*C > f(n) = n+3
而且是的 C = 2 会这样做,因此我们的函数 f(n) = n 可以是我们函数 f(x) = x + 3 的顶部界限。
相同的下限:
f(n) = n*C < f(n) = n+3
C = 2 會這樣做
从(源)可以读到:
大 O 评级根据其增长率定义函数:具有相同增长率的不同函数可以使用相同的 O 评级进行代表。
在计算机科学时间复杂性和空间复杂性理论中,人们可以认为大O评级是对时间和空间的某种最糟糕情况的算法的分类。
一个算法被称为采取线性时间/空间,或者O(n)时间/空间,如果其时间/空间复杂性是O(n)。
和 O(n log n) 如:
一个算法被称为在量子时间/空间中运行,如果T(n) = O(n log^k n)为某种积极的连续 k;线性时间/空间是 k = 1(来源)的情况。
此分類上一篇
仅仅是以快速而简单的方式表达一个算法的复杂性。 大 O 评分存在,以解释任何算法的最佳、最糟糕和平均案例时间复杂性。
否则,与这些功能工作是非常困难的,因为它们倾向于:
有太多的泡沫 - 像二进制搜索这样的算法通常运行得更快,因为序列分区工作得很好,因为 n = 2k − 1 的尺寸,因为序列分区工作得更快。 这个细节并不特别重要,但它警告我们,任何算法的准确时间复杂性功能可能非常复杂,如图2.2 所示,有很少的上下泡沫。
https://mimoza.marmara.edu.tr/~msakalli/cse706_12/SkienaTheAlgorithmDesignMan ual.pdf