时间复杂度

一:直观理解

作者:司马懿
链接:https://www.zhihu.com/question/21387264/answer/422323594
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
 

先从 O(1) 来说,理论上哈希表就是O(1)。因为哈希表是通过哈希函数来映射的,所以拿到一个关键字,用哈希函数转换一下,就可以直接从表中取出对应的值。和现存数据有多少毫无关系,故而每次执行该操作只需要恒定的时间(当然,实际操作中存在冲突和冲突解决的机制,不能保证每次取值的时间是完全一样的)。举个现实的例子,比如我的身后有一排柜子,里面有香蕉(代号B),苹果(代号A),葡萄(G),现在你说A,我迅速的就把苹果递过来了;你说B,我迅速就把香蕉递过来了。就算你再增加菠萝(P)、火龙果(H),但是你说一个代号,我递给你相应的水果这个速度是几乎不会变的。

 

至于 O(n) ,这个就是说随着样本数量的增加,复杂度也随之线性增加。典型的比如数数。如果一个人从1数到100,需要100秒,那么从1到200,基本上不会小于200秒,所以数数就是一个 O(n) 复杂度的事情。一般来说,需要序贯处理的算法的复杂度,都不会低于 O(n) 。比如说,如果我们要设计一个算法从一堆杂乱的考试的卷子里面找出最高的分数,这就需要我们从头到尾看完每一份试卷,显然试卷越多,需要的时间也越多,这就是一个 O(n) 复杂度的算法。

 

O(n^2) 是说,计算的复杂度随着样本个数的平方数增长。这个例子在算法里面,就是那一群比较挫的排序,比如冒泡、选择等等。沿着我们刚才的说的那个试卷的例子,等我们找出最高的分数之后,放在一边另起一堆,然后用同样的方法找第二高的分数,再放到新堆上…… 这样我们做n次,试卷就按照分数从低到高都排好了。因为有n份试卷,所以这种翻试卷,找最高分的行为,我们要做n次,每次的复杂度是 O(n) ,那么n个 O(n) 自然就是 O(n^2).

 

在比如说构建一个网络,每个点都和其他的点相连。显然,每当我们增加一个点,其实就需要构建这个点和所有现存的点的连线,而现存的点的个数是n,所以每增加1,就需要增加n个连接,那么如果我们增加n个点呢,那这个连接的个数自然也就是 n^2 量级了。

 

无论是翻试卷,还是创建网络,每增加一份试卷,每增加一个点,都需要给算法执行人带来n量级的工作量,这种算法的复杂度就是 O(n^2)

 

然后是 O(nlogn) ,这恐怕是常见算法复杂度里面相对最难理解的,就是这个log怎么来的。前面那个n,代表执行了n次 log(n) 的操作,所以理解了log(n),就理解了nlog(n)。

 

O(logn) 的算法复杂度,典型的比如二分查找。设想一堆试卷,已经从高到底按照分数排列了,我们现在想找到有没有59分的试卷。怎么办呢?先翻到中间,把试卷堆由中间分成上下两堆,看中间这份是大于还是小于59,如果大于,就留下上面那堆,别的丢掉,如果小于,就留下下面那堆,丢掉上面。然后按照同样的方法,每次丢一半的试卷,直到丢无可丢为止。

 

假如有32份试卷,你丢一次,还剩16份 ,丢两次,还剩下8 份,丢三次,就只剩下4份了,可以这么一直丢下去,丢到第五次,就只剩下一份了。而 log_2(32) = 5 。也就是我们一次丢一半,总要丢到只有一份的时候才能出结果,如果有n份,那么显然我们就有:

\frac{n}{2^k} = 1\Rightarrow k = log_2 n

也就是大约需要 log_2 n 次,才能得出“找到”或者“没找到”的结果。当然你说你三分查找,每次丢三分之二可不可以?当然也可以,但是算法复杂度在这里是忽略常数的,所以不管以2为底,还是以什么数为底,都统一的写成 log(n) 的形式。

 

理解了这一点,就可以理解快速排序为什么是 O(nlogn) 了。比如对一堆带有序号的书进行排序,怎么快呢?就是随便先选一本,然后把号码大于这本书的扔右边,小于这本书的扔左边。因为每本书都要比较一次,所以这么搞一次的复杂度是 O(n) ,那么快排需要我们搞多少次呢?这个又回到了二分查找的逻辑了,每次都把书堆一分为二,请问分多少次手里才能只剩下一本书呢?答案还是 logn 。而从代码的角度来说,在到达大小为一的数列之前,我们也是需要作 logn 次嵌套的调用。

作者:李斌
链接:https://zhuanlan.zhihu.com/p/32135157
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
 

2.1 - 大O表示法

用O(n)来体现算法时间复杂度的记法被称作大O表示法

一般我们我们评估一个算法都是直接评估它的最坏的复杂度。

大O表示法O(f(n))中的f(n)的值可以为1、n、logn、n^2 等,所以我们将O(1)、O(n)、O(logn)、O( n^2 )分别称为常数阶、线性阶、对数阶和平方阶。下面我们来看看推导大O阶的方法:

推导大O阶

推导大O阶有一下三种规则:

  1. 用常数1取代运行时间中的所有加法常数
  2. 只保留最高阶项
  3. 去除最高阶的常数

举好多栗子

  • 常数阶
let sum = 0, n = 10; // 语句执行一次 
let sum = (1+n)*n/2; // 语句执行一次 
console.log(`The sum is : ${sum}`) //语句执行一次 

这样的一段代码它的执行次数为 3 ,然后我们套用规则1,则这个算法的时间复杂度为O(1),也就是常数阶。

  • 线性阶
let i =0; // 语句执行一次 
while (i < n) { // 语句执行n次 
  console.log(`Current i is ${i}`); //语句执行n次
  i++; // 语句执行n次
}

这个算法中代码总共执行了 3n + 1次,根据规则 2->3,因此该算法的时间复杂度是O(n)。

  • 对数阶
let number = 1; // 语句执行一次 
while (number < n) { // 语句执行logn次
  number *= 2; // 语句执行logn次
}

上面的算法中,number每次都放大两倍,我们假设这个循环体执行了m次,那么2^m = nm = logn,所以整段代码执行次数为1 + 2*logn,则f(n) = logn,时间复杂度为O(logn)。

  • 平方阶
for (let i = 0; i < n; i++) { // 语句执行n次 
  for (let j = 0; j < n; j++) { // 语句执行n^2次 
     console.log('I am here!'); // 语句执行n^2
  }
}

上面的嵌套循环中,代码共执行 2*n^2 + n,则f(n) = n^2。所以该算法的时间复杂度为O(n^2 )

常见时间复杂度的比较

常见的时间复杂度函数相信大家在大学中都已经见过了,这里也不多做解释了:

O(1)<O(logn)<O(n)<O(nlogn)<O(n²)<O(n³)<O(2ⁿ)<O(n!)

 

展开阅读全文

没有更多推荐了,返回首页