算法中的复杂度分析
复杂度
前言
来复习下,算法体重经常聊到的复杂度
算法中我们经常会从两个角度去考虑算法的优劣,那就是【时间维度】和【空间维度】
时间复杂度
时间复杂度:就是执行当前算法消耗的时间。
当然我们这里讲的时间复杂度是个更加通用的描述,因为我们知道代码在不同中机器中执行的时间是不同的,性能好的机器可能就用的时间更短。
所以我们这里的时间复杂度,用的是【大O符号表示法】,即T(n) = O(f(n))
如何理解呢?先来个栗子
func sum(n int) int {
sum :=0
i:=3
for m:=0;m<n;m++ {
sum+=n*i+1
}
return sum
}
比如上面这段代码,循环了n次,那么时间复杂度就是O(n),如何分析呢?
我们假定每行代码执行的时间是一个时间颗粒,那我们上面的例子,第2和3行一共两个时间颗粒,4和5行就是2*n个时间颗粒,总共就是(2n+2)个时间颗粒。
当然这样算下来时间复杂度是T(n) = O(2n+2)
,大 O 时间复杂度实际上并不具体表示代码真正的执行时间,而是表示代码执行时间随数据规模增长的变化趋势,所以,也叫作渐进时间复杂度(asymptotic time complexity),简称时间复杂度。
如果 n 很大时,而公式中的低阶、常量、系数三部分并不左右增长趋势,所以都可以忽略。也就是2n中的2和常量2都可以忽略,所以时间复杂度就是T(n) = O(n)
常数阶O(1)
无论代码执行了多少行,只要是没有循环等复杂结构,那这个代码的时间复杂度就都是O(1),如:
func sum(n int) int {
sum :=0
i:=3
sum=sum*i
return sum
}
因为这段代码中没有一个系数,会导致代码的执行时间随系数的变化而变化,所以不管这个代码有多少行,都可以时间复杂度是 O(1)
一般情况下,只要算法中不存在循环语句、递归语句,即使有成千上万行的代码,其时间复杂度也是Ο(1)。
线性阶O(n)
比如我们刚开始的这个例子
func sum(n int) int {
sum :=0
i:=3
for m:=0;m<n;m++ {
sum+=n*i+1
}
return sum
}
代码中有个 for 循环,代码的执行时间会因为 n 的变化而变化,并且是线性增加或减少,所以这里用 O(n) 来表示他的时间复杂度。
对数阶O(logN)
func sum(n int) int {
sum :=0
for sum<n {
sum+=n*2
}
return sum
}
这里同样也是一个循环,只不过每次都乘以2。也就是2的 x 次方大于等于 n 。 执行的次数就是 x 。
![time-log](https://img2020.cnblogs.com/blog/1237626/202110/1237626-20211003210041881-1933118166.jpg)
接着上面转换的结果,对于省略掉常数2,所以时间复杂度就是 O(logN)
实际上,不管是以2为底、以3为底,还是以10为底,我们可以把所有对数阶的时间复杂度都记为 O(logn)
线性对数阶O(nlogN)
将上面的代码实例,外面在循环 n 次,时间复杂度就是下面我们要讨论的 O(nlogN)
func sum(n int) int {
sum :=0
for i:=0;i<n;i++{
for sum<n {
sum+=n*2
}
}
return sum
}
这个就不展开讨论了,内层循环是上面我们讨论的 O(logN) ,外面多了一层循环,所以时间复杂度就是 O(nlogN)
平方阶O(n²)
这个就很好理解了,就是两层代码的循环
func sum(m,n int) int {
sum :=0
for i:=0;i<m;i++{
for j:=0;j<n;j++ {
sum+=j
}
}
return sum
}
当然有三层循环就是 O(n³),依次类推
空间复杂度
空间复杂度全称就是渐进空间复杂度(asymptotic space complexity),表示算法的存储空间与数据规模之间的增长关系。
来个栗子分析下
func test(n int) map[int]struct{} {
testMap := make(map[int]struct{}, n)
for i := 0; i < n; i++ {
testMap[i] = struct{}{}
}
return testMap
}
比如上面的这段代码,空间复杂度是 O(n)
我们可以看到 for 开始的时候申请了一个变量 i ,这是常量级别的,跟数据规模 n 没有关系,所以我们可以忽略。我们初始化了一个长度为 n 的 testMap。testMap 的长度会根据 n 的变化而变化,所以这段代码的空间复杂度就是 O(n)。
常数阶O(1)
这个很简单
func sum(n int) int {
sum :=0
i:=3
sum=sum*i
return sum
}
因为没有变量跟随数据规模 n 的变化而变化,所以空间复杂度就是 O(1)。
平方阶O(n²)
看个栗子
func test(n int) [][]int {
var sil = make([][]int, n)
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
sil[i] = append(sil[i], j)
}
}
return sil
}
定义了二维切片,随着两层循环,分别申请了 n*n 个空间的大小,所以空间复杂度就是 O(n²)
当然有二维切片就是 O(n³),依次类推
最好、最坏情况时间复杂度
最好情况时间复杂度就是,在最理想的情况下,执行这段代码的时间复杂度。
最坏情况时间复杂度就是,在最糟糕的情况下,执行这段代码的时间复杂度。
比如这段代码
func sum(n, m int) int {
sum := 0
for i := 0; i < n; i++ {
if sum == m {
return sum
}
sum += i * 2
}
return sum
}
如果在第一次循环的时候,sum == m
就结束程序,那么这个时候的时间复杂度就是最好时间复杂度。
当然如果上面的 for 循环,遍历到最后一次也没满足 sum == m
,那么这个时候的时间复杂度就是最坏情况时间复杂度。
平均情况复杂度
顾名思义就是,最好和最坏的时间复杂度的平均值。
比如上面的那个例子
引入概率之后,前面那段代码的加权平均值为(3n+1)/4。用大O表示法来表示,去掉系数和常量,这段代码的加权平均时间复杂度仍然是O(n)。
均摊时间复杂度
对一个数据结构进行一组连续操作中,大部分情况下时间复杂度都很低,只有个别情况下时间复杂度比较高,而且这些操作之间存在前后连贯的时序关系,这个时候,我们就可以将这一组操作放在一块儿分析,看是否能将较高时间复杂度那次操作的耗时,平摊到其他那些时间复杂度比较低的操作上。而且,在能够应用均摊时间复杂度分析的场合,一般均摊时间复杂度就等于最好情况时间复杂度。
其实也可以认为均摊时间复杂度就是一种特殊的平均时间复杂度。
总结
这里大概介绍了空间复杂度和时间复杂度
时间复杂度的全称是渐进时间复杂度,表示算法的执行时间与数据规模之间的增长关系。类比一下,空间复杂度全称就是渐进空间复杂度(asymptotic space complexity),表示算法的存储空间与数据规模之间的增长关系。
这里的计算使用的是【大 O 复杂度表示法】,时间复杂度和空间复杂度只和数据规模 n 有关系,公式中的低阶、常量、系数三部分不影响增加趋势,所以不收这三个的影响。
参考
【算法的时间与空间复杂度(一看就懂)】https://zhuanlan.zhihu.com/p/50479555
【数据结构与算法之】https://time.geekbang.org/column/intro/100017301
【空间复杂度和时间复杂度】https://boilingfrog.github.io/2021/10/03/算法中的复杂度分析/