排版好乱啊
数据结构和算法本身解决的是“快”和“省”的问题,即如何让代码运行得更快,如何让代码更省存储空间。所以,执行效率是算法一个非常重要的考量指标。复杂度分析是整个算法学习的精髓,只要掌握了它,数据结构和算法的内容基本上就掌握了一半。
为什么要进行复杂度分析?
可以直接运行程序得到算法的执行时间和占用内存的大小,但是这样有局限性,首先,测试结果针对不同的硬件有不同的结果。i3的处理器和i9的处理器执行的速度肯定会有差异。其次,测试结果受数据规模的大小的影响。针对小规模数据,插入排序可能比快速排序要快!
针对以上问题,大O表示法应运而生,不用具体的测试数据就能粗略的计算执行效率。
大O表示法
公式:
其中,T(n)代表运行时间;n表示数据规模的大小;f(n)表示代码执行的次数总和。O表示执行时间T(n)和f(n)成正比。 大O时间复杂度表示法,实际上并不表示代码的真正的运行时间,而是代码执行时间随数据规模增长的变化趋势,因此,也叫渐进时间复杂度,简称时间复杂度
时间复杂度分析
1、只关注执行次数最多的一段代码
def cal(n):
sum = 0
i = 1
for j in range(n):
sum += i
return sum
其中第2,3行都是常量级的执行时间,与n无关,所以对复杂度并没有影响。循环执行次数最多的是4,5行,这两行被执行了n次,所以总的时间复杂度就是O(n)。
2、加法法则:总复杂度等于量级最大的那段代码的复杂度
def cal(n):
sum = 0
i = 1
for j in range(n):
sum += i
sum_1 = 0
q = 1
p = 1
for m in range(n):
p = 1
for l in range(n):
sum_1 += p * q
return sum + sum_1
sum_1 需要运行 O ( n 2 ) O(n^2) O(n2) 所以cal函数运行时间为 O ( n ) O(n) O(n) + O ( n 2 ) O(n^2) O(n2),根据加法法则就是 O ( n 2 ) O(n^2) O(n2)
3、乘法法则:嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
乘法法则可以看成是嵌套循环
def fun(n):
sum = 0
i = 1
for j in range(n):
sum += fun(i)
return sum
def cal(n):
sum = 0
i = 1
for j in range(n):
sum += fun(i)
return sum
以上函数时间复杂度表示为: T ( n ) = T 1 ( n ) ∗ T 2 ( n ) = O ( n ∗ n ) = O ( n 2 ) T(n)=T1(n)*T2(n)=O(n*n)=O(n^2) T(n)=T1(n)∗T2(n)=O(n∗n)=O(n2)
常见的时间复杂度
常量阶 O ( 1 ) O(1) O(1) 对数阶 O ( l o g n ) O(logn) O(logn) 线性阶 O ( n ) O(n) O(n) 线性对数阶 O ( n l o g n ) O(nlogn) O(nlogn) 指数阶 O ( 2 n ) O(2^n) O(2n) 阶成阶 O ( n ! ) O(n!) O(n!)
O ( 1 ) O(1) O(1)
一般只要算法不含有循环语句,递归语句,即使有上万行代码,时间复杂度依然是 O ( 1 ) O(1) O(1)
O ( l o g n ) O(logn) O(logn) O ( n l o g n ) O(nlogn) O(nlogn)
i = 1
while i < n:
i = i * 2
第三行代码是循环执行次数最多的。所以,我们只要能计算出这行代码被执行了多少次,就能知道整段代码的时间复杂度。
从代码中可以看出,变量i的值从1开始取,每循环一次就乘以2。当大于n时,循环结束。变量i的取值就是一个等比数列。
所以,我们只要知道x值是多少,就知道这行代码执行的次数了。通过
2
x
=
n
2^x=n
2x=n求解x这个问题我们想高中应该就学过了,我就不多说了。
x
=
l
o
g
2
n
x=log_2n
x=log2n,所以,这段代码的时间复杂度就是
O
(
l
o
g
2
n
)
O(log_2n)
O(log2n)。
更改代码,代码如下:
i = 1
while i < n:
i = i * 3
根据刚才分析这段代码的时间复杂度为 O ( l o g 3 n ) O(log_3n) O(log3n),实际上,不管是以2为底、以3为底,还是以10为底,我们可以把所有对数阶的时间复杂度都记为 O ( l o g n ) O(logn) O(logn)。 l o g 3 n log_3n log3n就等于 l o g 3 2 ∗ l o g 2 n log_32 * log_2n log32∗log2n,所以 O ( l o g 3 n ) = O ( C ∗ l o g 2 n ) O(log_3n) = O(C * log_2n) O(log3n)=O(C∗log2n),其中 C = l o g 3 2 C=log_32 C=log32是一个常量。基于我们前面的一个理论:在采用大O标记复杂度的时候,可以忽略系数,即 O ( C f ( n ) ) = O ( f ( n ) ) O(Cf(n)) = O(f(n)) O(Cf(n))=O(f(n))。所以,$O(log_2n) 就 等 于 就等于 就等于O(log_3n)$。因此,在对数阶时间复杂度的表示方法里,我们忽略对数的“底”,统一表示为 O ( l o g n ) O(logn) O(logn)。
3、O(m+n)、O(m*n)
def cal(n, m):
sum = 0
i = 1
for j in range(n):
sum += i
sum_1 = 0
p = 1
for m in range(m):
sum_1 += p
return sum + sum_1
从代码中可以看出,m和n是表示两个数据规模。我们无法事先评估m和n谁的量级大,所以我们在表示复杂度的时候,就不能简单地利用加法法则,省略掉其中一个。所以,上面代码的时间复杂度就是 O ( m + n ) O(m+n) O(m+n)。
针对这种情况,原来的加法法则就不正确了,我们需要将加法规则改为: T 1 ( m ) + T 2 ( n ) = O ( f ( m ) + g ( n ) ) T1(m) + T2(n) = O(f(m) + g(n)) T1(m)+T2(n)=O(f(m)+g(n))。但是乘法法则继续有效: T 1 ( m ) ∗ T 2 ( n ) = O ( f ( m ) ∗ f ( n ) ) T1(m)*T2(n) = O(f(m) * f(n)) T1(m)∗T2(n)=O(f(m)∗f(n))。
空间复杂度分析
空间复杂度全称就是渐进空间复杂度,表示算法的存储空间与数据规模之间的增长关系
为了更能说明问题,用c++表示
void print(int n) {
int i = 0;
int[] a = new int[n];
for (i; i <n; ++i) {
a[i] = i * i;
}
for (i = n-1; i >= 0; --i) {
print out a[i]
}
}
跟时间复杂度分析一样,我们可以看到,第2行代码中,我们申请了一个空间存储变量i,但是它是常量阶的,跟数据规模n没有关系,所以我们可以忽略。第3行申请了一个大小为n的int类型数组,除此之外,剩下的代码都没有占用更多的空间,所以整段代码的空间复杂度就是 O ( n ) O(n) O(n)。
我们常见的空间复杂度就是 O ( 1 ) 、 O ( n ) 、 O ( n 2 ) O(1)、O(n)、O(n2 ) O(1)、O(n)、O(n2),像 O ( l o g n ) 、 O ( n l o g n ) O(logn)、O(nlogn) O(logn)、O(nlogn)这样的对数阶复杂度平时都用不到。而且,空间复杂度分析比时间复杂度分析要简单很多。所以,对于空间复杂度,掌握这些内容已经足够了。
复杂度分析(摘自一个网友的分享):
1)单段代码看高频:比如循环。
2)多段代码取最大:比如一段代码中有单循环和多重循环,那么取多重循环的复杂度。
3)嵌套代码求乘积:比如递归、多重循环等
4)多个规模求加法:比如方法有两个参数控制两个循环的次数,那么这时就取二者复杂度相加。
附上一篇不错的文章连接在此