说明
【数据结构与算法之美】专栏学习笔记。
什么是复杂度?
复杂度也叫渐进复杂度
,包括时间复杂度和空间复杂度,用来分析算法执行效率与数据规模之间的增长关系,可以粗略地表示,越高阶复杂度的算法,执行效率越低。
常见的复杂度从低阶到高阶有:O(1)、O(logn)、O(n)、O(nlogn)、O( n^2 )。
为什么需要复杂度分析?
性能测试的局限性:
- 测试结果非常依赖测试环境
- 测试结果受数据规模的影响很大
复杂度分析有不依赖执行环境、成本低、效率高、易操作、指导性强的特点。
大 O 复杂度表示法
也叫作渐进时间复杂度(asymptotic time complexity)
,简称时间复杂度
,它不具体表示代码真正的执行时间,只是表示代码执行时间随数据规模增长的变化趋势。
算法的执行效率,粗略地讲,就是算法代码执行的时间。所有代码的执行时间 T(n) 与每行代码的执行次数 f(n) 成正比。
T(n) = O(f(n))
T(n):表示代码执行的时间
n:表示数据规模的大小
f(n) :表示每行代码执行的次数总和
O:表示代码的执行时间 T(n) 与 f(n) 表达式成正比。
举个例子:
int cal(int n) { int sum = 0; int i = 1; int j = 1; for (; i <= n; ++i) { j =1; for (; j <= n; ++j) { sum = sum + i * j; } } }
上面代码,我们假设每个语句的执行时间是 unit_time,那么
第 2、3、4 行代码都需要 1 个 unit_time 的执行时间
第 5、6 行代码循环执行了 n 遍,需要 2n * unit_time 的执行时间
第 7、8 行代码循环执行了 n^2 遍,需要 22 n^2 * unit_time 的执行时间
综上,上面整段代码总的执行时间 T(n) = ( 2 n^2 + 2n + 3) * unit_time。
大 O 时间复杂度表示法:T(n) = O( n^2 + 2n + 3)。当 n 很大,低阶、常量、系数不左右增长趋势,可以忽略这些项,记录一个最大量级即可:T(n) = O( n^2 )。
时间复杂度分析
1、循环执行次数最多法则
只关注循环执行次数最多的一段代码
大 O 复杂度表示方法只是表示一种变化趋势,通常会忽略掉公式中的常量、低阶、系数,只需要记录一个最大阶的量级即可。
int cal(int n) { int sum = 0; int i = 1; for (; i <= n; ++i) { sum = sum + i; } return sum; }
比如上面这个例子,循环执行次数最多的是第 4、5 行代码,时间复杂度就是 O(n)。
2、加法法则
总的时间复杂度就等于量级最大的那段代码的时间复杂度。
int cal(int n) { int sum_1 = 0; int p = 1; for (; p < 100; ++p) { sum_1 = sum_1 + p; } int sum_2 = 0; int q = 1; for (; q < n; ++q) { sum_2 = sum_2 + q; } int sum_3 = 0; int i = 1; int j = 1; for (; i <= n; ++i) { j = 1; for (; j <= n; ++j) { sum_3 = sum_3 + i * j; } } return sum_1 + sum_2 + sum_3; }
上面代码可以分成3段代码来看:
第一段:可以忽略掉
第二段:时间复杂度为 O(n)
第三段:时间复杂度为 O( n^2 )
这三段代码的时间复杂度,取其中最大的量级 O( n^2 )。
公式表示如下:
T(n) = T1(n) + T2(n) = max(O(f(n)), O(g(n))) = O(max(f(n), g(n)))
3、乘法法则
嵌套代码的复杂度等于嵌套内外代码复杂度的乘积。
公式如下:
T(n) = T1(n) * T2(n) = O(f(n)) * O(g(n)) = O(f(n) * g(n))
int cal(int n) { int ret = 0; int i = 1; for (; i < n; ++i) { ret = ret + f(i); } } int f(int n) { int sum = 0; int i = 1; for (; i < n; ++i) { sum = sum + i; } return sum; }
上面的代码里 for 循环嵌入了另外一个函数,这个代码时间复杂度就是T(n) = T1(n) * T2(n) = O(n * n) = O( n 2 n^2 n2)。
几种常见时间复杂度实例分析
复杂度量级分类:
多项式量级
非多项式量级
O(2^n )
O(n!)
时间复杂度为非多项式量级的算法问题叫作 NP(Non-Deterministic Polynomial,非确定多项式)
问题。
下面看几种常见的多项式时间复杂度:
1、O(1)
O(1) 只是常量级时间复杂度
的一种表示方法,并不是指只执行了一行代码。只要算法中不存在循环语句、递归语句,代码的执行时间不随 n 的增大而增长,不管代码多少行,其时间复杂度也是Ο(1)。
2、O(logn)、O(nlogn)
i=1; while (i <= n) { i = i * 2; }
上面列出来就是这样的效果
2^0 2^1 …2^x = n
这里知道 x 值即可,就能知道 while 这行代码执行的次数,我们通过 2 x 2^x 2x = n 求解得到 x = l o g 2 log_2 log2n,时间复杂度就是 O( l o g 2 log_2 log2n)。
由于对数之间是可以互相转换的,所以在对数阶时间复杂度的表示方法里,我们可以忽略对数的“底”,统一表示为 O(logn)。
对于 O(nlogn) 就是上面讲的乘法规则:一段代码的时间复杂度是 O(logn),循环执行 n 遍,时间复杂度就是 O(nlogn) ,比如,归并排序、快速排序的时间复杂度都是 O(nlogn)。
3、O(m+n)、O(m*n)
int cal(int m, int n) { int sum_1 = 0; int i = 1; for (; i < m; ++i) { sum_1 = sum_1 + i; } int sum_2 = 0; int j = 1; for (; j < n; ++j) { sum_2 = sum_2 + j; } return sum_1 + sum_2; }
上面代码里 m 和 n 是表示两个数据规模,无法确定那个大,所以不能忽略其中一个,这里的时间复杂度就是 O(m + n)。
- 加法规则:T1(m) + T2(n) = O(f(m) + g(n))
- 乘法法则:T1(m) * T2(n) = O(f(m) * f(n))。
空间复杂度分析
也叫渐进空间复杂度(asymptotic space complexity)
,表示算法的存储空间与数据规模之间的增长关系。
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] } }
上面代码空间复杂度就是 O(n)。
- 第 2 行代码:申请了一个空间存储变量 i,但是它是常量阶的,跟数据规模 n 没有关系,可以忽略。
- 第 3 行代码:申请了一个大小为 n 的 int 类型数组
常见的空间复杂度就是 O(1)、O(n)、O( n^2 ),像 O(logn)、O(nlogn) 对数阶复杂度平时用不上,空间复杂度分析比时间复杂度分析要简单很多。