所以上边两个函数的执行时间可以标记为 T(n) = O(2n+1) 和 T(n) = O(2n2+n+1)。这就是大 O 时间复杂度表示法,它不代表代码真正的执行时间,而是表示代码随数据规模增长的变化趋势,简称时间复杂度。
而且当 n 很大时,我们可以忽略常数项,只保留一个最大量级即可。所以上边的代码执行时间可以简单标记为 T(n) = O(n) 和 T(n) = O(n2)。
时间复杂度分析
那如何分析一段代码的时间复杂度呢,可以利用下面的几个方法
1.只关注循环执行次数最多的一段代码
我们在分析一段代码的时间复杂度时,我们只要关注循环次数最多的那一段代码就 ok 了。
比如说在第一段代码中
function total(n) { // 1
var sum = 0; // 2
for (var i = 0; i < n; i++) { // 3
sum += i; // 4
} //5
} //6
复制代码
只有第 3 行和第 4 行是执行次数最多的,分别执行了 n 次,那么忽略常数项,所以此段代码的时间复杂度就是 O(n)。
2.加法法则:总复杂度等于量级最大的那段代码的复杂度。
比如说,看下面这段代码的时间复杂度。
function total(n) {
// 第一个 for 循环
var sum1 = 0;
for (var i = 0; i < n; i++) {
for (var j = 0; j < n; j++) {
sum1 = sum1 + i + j;
}
}
// 第二个 for 循环
var sum2 = 0;
for(var i=0;i<1000;i++) {
sum2 = sum2 + i;
}
// 第三个 for 循环
var sum3 = 0;
for (var i = 0; i < n; i++) {
sum3 = sum3 + i;
}
}
复制代码
我们先分别分析每段 for 循环的时间复杂度,再取他们中最大的量级来作为整段代码的时间复杂度。
第一段 for 循环的时间复杂度为 O(n2)。
第二段 for 循环执行了 1000 次,是个常数量级,尽管对代码的执行时间会有影响,但是当 n 无限大的时候,就可以忽略。因为它本身对增长趋势没有影响,所以这段代码的时间复杂度可以忽略。
第三段 for 循环的时间复杂度为 O(n)。
总上,取最大量级,所以整段代码的时间复杂度为 O(n2)。
3.乘法法则:嵌套代码的复杂度等于嵌套内外代码复杂度的乘积。
比如说,看下面这段代码的时间复杂度
function f(i) {
var sum = 0;
for (var j = 0; j < i; j++) {
sum += i;
}
return sum;
}
function total(n) {
var res = 0;
for (var i = 0; i < n; i++) {
res = res + f(i); // 调用 f 函数
}
}
复制代码
单独看 total 函数的时间复杂度就是为 T1(n)=O(n),但是考虑到 f 函数的时间复杂度也为 T2(n)=O(n)。
所以整段代码的时间复杂度为 T(n) = T1(n) * T2(n) = O(n*n)=O(n2)。
几种常见的时间复杂度分析
只看最高量级的复杂度,下图中效率是递减的
如上图可以粗略的分为两类,多项式量级和非多项式量级。其中,非多项式量级只有两个:O(2n) 和 O(n!)
对应的增长率如下图所示
当数据规模 n 增长时,非多项式量级的执行时间就会急剧增加,所以,非多项式量级的代码算法是非常低效的算法。
1. O(1)
O(1) 只是常量级时间复杂度表示法,并不是代码只有一行,比如说下面这段代码
functiontotal() {
var sum = 0;
for(var i=0;i<100;i++) {
sum += i;
}
}
复制代码
虽然有这么多行,即使 for 循环执行了 100 次,但是代码的执行时间不随 n 的增大而增长,所以这样的代码复杂度就为 O(1)。
2. O(logn)、O(nlogn)
对数阶时间复杂度的常见代码如下
function total1(n) {
var sum = 0;
var i = 1;
while (i <= n) {
sum += i;
i = i * 2;
}
}
function total2(n) {
var sum = 0;
for (var i = 1; i <= n; i = i * 2) {
sum += i;
}
}
复制代码
上面两个函数都有一个相同点,变量 i 从 1 开始取值,每循环一次乘以 2,当大于 n 时,循环结束。实际上,i 的取值就是一个等比数列,就像下面这样
20 21 22 ... 2k... 2x =n;
所以只要知道 x 的值,就可以知道这两个函数的执行次数了。那由 2x = n 可以得出 x = log2n,所以这两个函数的时间复杂度为 O(log2n)。
再看下面两个函数的时间复杂度
function total1(n) {
var sum = 0;
var i = 1;
while (i <= n) {
sum += i;
i = i * 3;
}
}
function total2(n) {
var sum = 0;
for (var i = 1; i <= n; i = i * 3) {
sum += i;
}
}
复制代码
由上可以得知,这两个函数的时间复杂度为 O(log3n) 。
由于我们可以忽略常数,也可以忽略对数中的底数,所以在对数阶复杂度中,统一表示为 O(logn);那 O(nlogn) 的含义就很明确了,时间复杂度 为O(logn) 的代码执行了 n 次。
3. O(m+n)、O(m*n)
再来看一段特殊的代码时间复杂度,比如说
function total(m,n) {
var sum1 = 0;
for (var i = 0; i < n; i++) {
sum1 += i;
}
var sum2 = 0;
for (var i = 0; i < m; i++) {
sum2 += i;
}
return sum1 + sum2;
}
复制代码
因为我们无法评估 m 和 n 谁的量级比较大,所以就不能忽略掉其中一个,这个函数的复杂度是有两个数据的量级来决定的,所以此函数的时间复杂度为 O(m+n);那么 O(m*n) 的时间复杂度类似。
新的一年,先给大家整理分享一个简单而又重要的知识点:时间复杂度和空间复杂度。因为在前几篇文章中,提到了时间复杂度,也许有些小伙伴还不清楚。(ps:希望在我上篇文章留言的那位小伙伴别失望哦,慢慢来。)
为什么需要复杂度分析
所以需要一个不用准确的测试结果来衡量,就可以粗略地估计代码执行时间的方法。这就是复杂度分析。
大 O 复杂度表示法
以一个例子开始,请估算下面代码的执行时间
function total(n) { // 1 var sum = 0; // 2 for (var i = 0; i < n; i++) { // 3 sum += i; // 4 } //5 } //6 复制代码
我们假设每行代码执行的时间都一样,记做 t,那么上面的函数中的第 2 行需要 1 个 t 的时间,第 3 行 和 第 4 行分别需要 n 个 t 的时间,那么这段代码总的执行时间为 (2n+1)*t。
那么按照上面的分析方法,请估算下面代码的执行时间
function total(n) { // 1 var sum = 0; // 2 for (var i = 0; i < n; i++) { // 3 for (var j = 0; j < n; j++) { // 4 sum = sum + i + j; // 5 } } } 复制代码
第 2 行需要一个 t 的时间,第 3 行需要 n 个 t 的时间,第 4 行和第 5 行分别需要 n2 个的时间,那么这段代码总的执行时间为 (2n2+n+1)*t 的时间。
从数学角度来看,我们可以得出个规律:代码的总执行时间 T(n) 与每行代码的执行次数成正比
在这个公式中,T(n) 表示代码的执行时间;n 表示数据规模的大小;f(n) 表示每行代码执行的次数总和;O 表示代码的执行时间 T(n) 与 f(n) 表达式成正比。
所以上边两个函数的执行时间可以标记为 T(n) = O(2n+1) 和 T(n) = O(2n2+n+1)。这就是大 O 时间复杂度表示法,它不代表代码真正的执行时间,而是表示代码随数据规模增长的变化趋势,简称时间复杂度。
而且当 n 很大时,我们可以忽略常数项,只保留一个最大量级即可。所以上边的代码执行时间可以简单标记为 T(n) = O(n) 和 T(n) = O(n2)。
时间复杂度分析
那如何分析一段代码的时间复杂度呢,可以利用下面的几个方法
1.只关注循环执行次数最多的一段代码
我们在分析一段代码的时间复杂度时,我们只要关注循环次数最多的那一段代码就 ok 了。 比如说在第一段代码中
function total(n) { // 1 var sum = 0; // 2 for (var i = 0; i < n; i++) { // 3 sum += i; // 4 } //5 } //6 复制代码
只有第 3 行和第 4 行是执行次数最多的,分别执行了 n 次,那么忽略常数项,所以此段代码的时间复杂度就是 O(n)。
2.加法法则:总复杂度等于量级最大的那段代码的复杂度。
比如说,看下面这段代码的时间复杂度。
function total(n) { // 第一个 for 循环 var sum1 = 0; for (var i = 0; i < n; i++) { for (var j = 0; j < n; j++) { sum1 = sum1 + i + j; } } // 第二个 for 循环 var sum2 = 0; for(var i=0;i<1000;i++) { sum2 = sum2 + i; } // 第三个 for 循环 var sum3 = 0; for (var i = 0; i < n; i++) { sum3 = sum3 + i; } } 复制代码
我们先分别分析每段 for 循环的时间复杂度,再取他们中最大的量级来作为整段代码的时间复杂度。
第一段 for 循环的时间复杂度为 O(n2)。
第二段 for 循环执行了 1000 次,是个常数量级,尽管对代码的执行时间会有影响,但是当 n 无限大的时候,就可以忽略。因为它本身对增长趋势没有影响,所以这段代码的时间复杂度可以忽略。
第三段 for 循环的时间复杂度为 O(n)。
总上,取最大量级,所以整段代码的时间复杂度为 O(n2)。
3.乘法法则:嵌套代码的复杂度等于嵌套内外代码复杂度的乘积。
比如说,看下面这段代码的时间复杂度
function f(i) { var sum = 0; for (var j = 0; j < i; j++) { sum += i; } return sum; } function total(n) { var res = 0; for (var i = 0; i < n; i++) { res = res + f(i); // 调用 f 函数 } } 复制代码
单独看 total 函数的时间复杂度就是为 T1(n)=O(n),但是考虑到 f 函数的时间复杂度也为 T2(n)=O(n)。 所以整段代码的时间复杂度为 T(n) = T1(n) * T2(n) = O(n*n)=O(n2)。
几种常见的时间复杂度分析
只看最高量级的复杂度,下图中效率是递减的
如上图可以粗略的分为两类,多项式量级和非多项式量级。其中,非多项式量级只有两个:O(2n) 和 O(n!) 对应的增长率如下图所示 当数据规模 n 增长时,非多项式量级的执行时间就会急剧增加,所以,非多项式量级的代码算法是非常低效的算法。1. O(1)
O(1) 只是常量级时间复杂度表示法,并不是代码只有一行,比如说下面这段代码
function total() { var sum = 0; for(var i=0;i<100;i++) { sum += i; } } 复制代码
虽然有这么多行,即使 for 循环执行了 100 次,但是代码的执行时间不随 n 的增大而增长,所以这样的代码复杂度就为 O(1)。
2. O(logn)、O(nlogn)
对数阶时间复杂度的常见代码如下
function total1(n) { var sum = 0; var i = 1; while (i <= n) { sum += i; i = i * 2; } } function total2(n) { var sum = 0; for (var i = 1; i <= n; i = i * 2) { sum += i; } } 复制代码
上面两个函数都有一个相同点,变量 i 从 1 开始取值,每循环一次乘以 2,当大于 n 时,循环结束。实际上,i 的取值就是一个等比数列,就像下面这样
所以只要知道 x 的值,就可以知道这两个函数的执行次数了。那由 2x = n 可以得出 x = log2n,所以这两个函数的时间复杂度为 O(log2n)。
再看下面两个函数的时间复杂度
function total1(n) { var sum = 0; var i = 1; while (i <= n) { sum += i; i = i * 3; } } function total2(n) { var sum = 0; for (var i = 1; i <= n; i = i * 3) { sum += i; } } 复制代码
由上可以得知,这两个函数的时间复杂度为 O(log3n) 。
由于我们可以忽略常数,也可以忽略对数中的底数,所以在对数阶复杂度中,统一表示为 O(logn);那 O(nlogn) 的含义就很明确了,时间复杂度 为O(logn) 的代码执行了 n 次。
3. O(m+n)、O(m*n)
再来看一段特殊的代码时间复杂度,比如说
function total(m,n) { var sum1 = 0; for (var i = 0; i < n; i++) { sum1 += i; } var sum2 = 0; for (var i = 0; i < m; i++) { sum2 += i; } return sum1 + sum2; } 复制代码
因为我们无法评估 m 和 n 谁的量级比较大,所以就不能忽略掉其中一个,这个函数的复杂度是有两个数据的量级来决定的,所以此函数的时间复杂度为 O(m+n);那么 O(m*n) 的时间复杂度类似。
空间复杂度分析
空间复杂度的话和时间复杂度类似推算即可。 所谓空间复杂度就是表示算法的存储空间和数据规模之间的关系。
比如说分析下面代码的空间复杂度:
function initArr(n) { var arr = []; for (var i = 0; i < n; i++) { arr[i] = i; } } 复制代码
根据时间复杂度的推算,忽略掉常数量级,每次数组赋值都会申请一个空间存储变量,所以此函数的空间复杂度为 O(n)。
常见的空间复杂度只有 O(1)、O(n)、O(n2)。其他的话很少会用到。
思考题解答
现在我们回到开始的思考题上,代码实现很简单:
function total(n) { var sum = 0; for (var i = 1; i <= n; i++) { sum += i; } return sum; } 复制代码
此函数的时间复杂度你现在应该很容易就能看出来了,为 O(n)。
我觉得这个时间复杂度有点高了,我想要 O(1) 的时间复杂度函数来实现这个算法,可以吗?
可以的,小数学神通高斯教会我们一招,如下
function total(n) { var sum = n*(n+1)/2 return sum; } 复制代码
此函数的时间复杂度仅仅为 O(1),在数据规模比较庞大的时候,下面的函数是不是明显比上面的函数运算效率更高呢。
总结
学习了复杂度分析后,是不是能避免写出效率低的代码呢?来给你的代码做个分析吧。
重点
如果有错误或者错别字,还请给我留言指出,谢谢。
我们下期见。