算法复杂度分析

通过代码的运行统计和监控可以得到的算法执行时间消耗和内存消耗，这种统计方法叫做‘事后统计法’。

但是这种统计方法有比较大的局限性，比如：

测试结果非常依赖测试环境，相同的代码在不同的处理器上运行速度有很大的差别。
测试结果受测试数据规模的影响很大，对同一个排序算法，待排序数据的有序度不一样，排序的执行时间就会有很大的差别。测试数据规模太小也很难真实反应算法的性能，比如，对于小规模的数据排序，插入排序可能反倒会比快速排序要快！

而这里所说的算法复杂度分析，叫做‘事前预测法’，不需要具体的测试数据来测试，就可以粗略地估算算法的执行效率。

一、时间复杂度分析(也就是分析和统计算法的执行效率)

大 O 复杂度表示法

T(n) = O（f(n)），大 O 的时间复杂度并不具体表现代码真正的执行时间，而是代码执行时间随数据规模增长的趋势，当n很大时，公式中的低阶、常量、系数三部分并不左右增长趋势，可以忽略，只需要记录一个最大量级就可以了。也就是说只关心循环执行次数最多的一段代码。

几种常见的时间复杂度，以下几种复杂度量级几乎涵盖了所有代码的复杂度量级。

O(1) 表示常量级时间复杂度的一种表示方法,比如以下代码：

 let i = 8;
 let j = 6;
 let sum = i + j;

也就是说只要代码的执行时间不随 n 的增大而增长，这样代码的时间复杂度我们都记作 O(1)，一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。

O(logn)、O(nlogn)，对数阶时间复杂度非常常见也是最难分析的一种时间复杂度。

 let i=1; 
 while (i <= n) {
 i = i * 2; 
 }

这段代码的时间复杂度就是 O(log2n)。

 let i=1; 
 while (i <= n) {
 i = i * 3; 
 }

这段代码的时间复杂度就是 O(log3n)。在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。所以上面2段代码的时间复杂度都计为 O(logn)。

O(m+n)、O(m*n)，代码的复杂度由两个数据的规模来决定，

 function add(m, n) {
  let sum_1 = 0;
  let i = 1;
  for (; i < m; ++i) {
    sum_1 = sum_1 + i;
  }

  let sum_2 = 0;
  let j = 1;
  for (; j < n; ++j) {
    sum_2 = sum_2 + j;
  }

  return sum_1 + sum_2;
}

从代码中可以看出，m和n表示2个数据规模，我们事先无法评估m和n谁的量级更大，无法省略任何一个，所以时间复杂度就是O（m+n）

二、最好、最坏情况时间复杂度

// n表示数组array的长度
function find(array, x) {  
    let index = -1
    for (var i = 0; i < array.length; i++) {  
        if (array[i] === x) {  
            index = i; // 找到x，返回索引  
        }  
    }  
    return index; // 没找到x，返回-1  
}

这段代码要实现的功能是，在一个无序的数组（array）中，查找变量 x 出现的位置。如果没有找到，就返回 -1。这段代码的复杂度是 O(n)，其中，n 代表数组的长度。

我们在数组中查找一个数据，并不需要每次都把整个数组都遍历一遍，因为有可能中途找到就可以提前结束循环了。但是，这段代码写得不够高效。我们可以这样优化一下这段查找代码。

// n表示数组array的长度
function find(array, x) {  
    let index = -1
    for (var i = 0; i < array.length; i++) {  
        if (array[i] === x) {  
            index = i; // 找到x，返回索引
            return; // 跳出循环
        }  
    }  
    return index; // 没找到x，返回-1  
}

那么，这段代码的时间复杂度还是O(n)吗，要查找的变量x可能出现在数组的任意位置，如果数组中第一个元素正好是要查找的变量x,那就不需要继续遍历，时间复杂度为O(1),如果数组中不存在x,就需要把整个数组都遍历一遍，时间复杂度为O(n),所以不同的情况，这段代码的时间复杂度是不一样的。为了表示代码在不同情况的时间复杂度，引入以下几个概念：：最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度。

最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。比如以上代码中要查找的变量 x 正好是数组的第一个元素，这个时候对应的时间复杂度就是最好情况时间复杂度。

最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。比如以上代码中如果数组中没有要查找的变量 x，我们需要把整个数组都遍历一遍才行，所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度

三、平均情况时间复杂度

以上的代码中，n个数据，就是n种情况，在加上一个不在n个数据中的情况，所以共有n+1中情况，则 1+..+n为n(n+1)/2 ，则再加个n就为n(n+3)/2 ，在除以n+1为n(n+3)/2(n+1)，大 O 标记法中，可以省略掉系数、低阶、常量，所以，得到的平均时间复杂度就是 O(n)。一般情况下,我们只需要使用普通复杂度分析就够了，只有在特殊情况下,我们才需要分析一段代码的三种复杂度，这种特殊情况就是: 同一个代码块在不同的情况下,时间复杂度有量级的差距，这个时候我们才会采用最好时间复杂度, 最坏时间复杂度,平均时间复杂度来表示该段代码的时间复杂度。

四、均摊时间复杂度

对一个数据结构进行一组连续操作中，大部分情况下时间复杂度都很低，只有个别情况下时间复杂度比较高，而且这些操作之间存在前后连贯的时序关系，这个时候，我们就可以将这一组操作放在一块儿分析，看是否能将较高时间复杂度那次操作的耗时，平摊到其他那些时间复杂度比较低的操作上。而且，在能够应用均摊时间复杂度分析的场合，一般均摊时间复杂度就等于最好情况时间复杂度。

五、空间复杂度分析（也就是分析和统计算法的资源消耗）

空间复杂度，表示算法的存储空间与数据规模之间的增长关系。我们常见的空间复杂度就是 O(1)（常数阶）、O(n)（线性阶）、O(n^2)（平方阶），像 O(logn)（对数阶）、O(nlogn)(线性对数阶) 这样的对数阶复杂度平时都用不到。

function filArr(n) {  
    let i=0;
    let a = new Array(n).fill(0); // 创建一个长度为n的数组，并用0填充  
    for (i;i<n;i++) {  
        a[i] = i * i;
    }
    for (i = n - 1; i >= 0; i--) {  
    console.log(a[i]); // 打印数组元素  
    } 
}

第 2 行代码中，我们申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没有关系，所以我们可以忽略。第 3 行申请了一个大小为 n 的数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。

总结：复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率越低。常见的复杂度并不多，从低阶到高阶有：O(1)、O(logn)、O(n)、O(nlogn)、O(n2 )。

算法--时间复杂度分析&&空间复杂度分析