算法复杂度分析

复杂度分析用来做什么？

  当我们设计一个算法的时候，我们希望让设计的代码运行的更快，更省内存。但是如何考量以上两个指标呢？我们需要通过时间、空间复杂度分析的方式来进行考量。复杂度分析对算法来说非常的重要，也是整个算法学习的精髓。

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

为什么要做复杂度分析？

  当然，我们写完之后把代码跑一遍，也能得到算法损耗的时间以及存储空间（像力扣刷题一样）。

我们做数据分析真的能比把代码跑一遍准确吗？

  首先，把代码跑一遍的评估方法是正确的，一些书籍将其称作事后统计法。但是，这些方法拥有局限性。局限性体现在以下方面。

1. 测试结果高度依赖于测试环境

  测试环境中硬件的不同（处理器i9比i3快很多）将影响测试结果。我们也许会遇到在某台处理器上代码a比代码b快，换一台处理器结果就会反过来的情况。

2. 测试结果受数据规模影响更大

  对同一个排序算法，待排序数据的有序度不一样，排序的执行时间就会有很大的差别。（排序算法，如果用例本身有序那么什么都不用做）
  如果测试数据规模太小，测试结果可能无法真实地反映算法的性能（比如，对于小规模的数据排序，插入排序可能反倒会比快速排序要快）。
  如果测试数据体量太大（达到TB级或者PB级），简单的一个wordCount操作也需要大数据生态的数据处理组件来解决。

复杂度分析表示方法

O复杂度表示法

  从CPU的角度看，我们程序的每一行都在执行着读数据-运算-写数据的操作。尽管每行代码对应的cpu的执行个数及时间都不一样，但是由于我们现在讨论的没有那么精准，所以假设每行代码执行时间都一样。我们假设这个值为time。

有段代码用来求数从1到n的累加和，代码如下：

 int cal(int n) { 
    int sum = 0; int i = 1; for (; i <= n; ++i) { 
    sum = sum + i; } return sum; } 

  由以上代码可以看出，在for循环前的代码每行执行了一遍，在for循环及其中的代码每行执行了n遍，那么总消耗时间为(2+2n)*time，可以看出，所有代码的时间消耗T(n)与每行代码的执行次数成正比（代码行数越多，执行时间越长）。
  这种正比的关系，我们可以按照O表示法来表示。

• n用来表示数据规模的大小
• f(n)表示代码执行次数的总和
• O用来表示正比的关系

那么以上代码块的正比关系可以用T(n) = O(2n+2)来表示。

  这里的O表示法并不表示代码真正的执行时间，而是表示一种代码执行时间随着数据规模增长的变化趋势，也叫渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

  由于公式中的常量、系数和低阶并不左右这种对应关系的增长趋势，所以我们只记一个最大量级即可。即T(n) = O(n)。

如何分析一段代码的时间复杂度？三个方法

1.只关注执行次数最多的一段代码

  我们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了（由于常量，低阶和系数在O时间复杂度表示法中可省略，因为它们量级低，执行次数最多的一段代码才会是高量级）。

2.加法法则：总复杂度等于量级最大的那段代码的复杂度

  执行次数是n次的代码和执行次数是n²的代码在一起，总的复杂度是O(n²)。因为当n无限大的时候，n的时间复杂度可以省略，因为它对正比对应关系的趋势没影响。

加法法则对应成公式的形式：如果 T1(n)=O(f(n))，T2(n)=O(g(n))；那么 T(n)=T1(n)+T2(n)=max(O(f(n)), O(g(n))) =O(max(f(n), g(n))).

3. 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

乘法法则是一个嵌套循环的情况：

 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; } 

  上面的循环，T1(n) = O(n)，但f()方法内还有一个循环，T2(n) = O(n)。总体的时间复杂度需要进行一个乘法运算，即T(n) = T1(n) * T2(n) = O(n*n) = O(n2)。

常见的时间复杂度的量级

常见的时间复杂度的量级分为两种：

• 多项式量级（左侧），这类能找到多项式级时间复杂度的解决算法的问题叫做P（Deterministic ）问题
• 非多项式量级（右侧），这类解决它的时间复杂度为非多项式量级的算法问题叫作 NP（Non-Deterministic Polynomial，非确定多项式）问题。
  
    当数据规模 n 越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法其实是非常低效的算法。

  
  
  
  

常量阶O(1)

  O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。，只要代码的执行时间不随 n 的增大而增长，这样代码的时间复杂度我们都记作 O(1)。或者说，一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。比如，哈希查找

O(logn)、O(nlogn)

  对数阶非常的常见，从我们的快排,归并，到我们的二分查找都有涉及。

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

  以上代码可以看到，循环中的行执行次数是最多的，我们可以看出，它的执行次数取决于n的大小。具体的执行过程如下：

• i从1开始，进入循环
• 每循环一次，i的值都会进行*2的操作
• 直到i的值大于n，那么退出循环

  求解 x 这个问题我们通过高中时期的指数对数运算方法可以得到，x=log2n，所以，这段代码的时间复杂度就是 O(log2n)。

  那么，如果中间是以3为底呢？如果是以100为底呢？

我们可以把所有对数阶的时间复杂度都记为 O(logn)。

log3n 就等于 log 3²* log2n，所以 O(log3n) = O(C * log2n)，其中 C=log 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 是表示两个数据规模。我们无法事先评估 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] } } 

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

我们常见的空间复杂度就是 O(1)、O(n)、O(n2 )，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。

针对不同输入情况下复杂度量级不同：时间复杂度分析（最好，最坏，平均，均摊）

最好，最坏时间复杂度分析

先看个例子：

以下代码用来暴力查找数组中元素x的位置，如果不存在则返回-1

 // n表示数组array的长度 int find(int[] array, int n, int x) { 
    int i = 0; int pos = -1; for (; i < n; ++i) { 
    if (array[i] == x) pos = i; } return pos; } 

 // n表示数组array的长度 int find(int[] array, int n, int x) { 
    int i = 0; int pos = -1; for (; i < n; ++i) { 
    if (array[i] == x) { 
    pos = i; break; } } return pos; } 

最好情况时间复杂度（best case time complexity）

  最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。就像我们刚刚讲到的，在最理想的情况下，要查找的变量 x 正好是数组的第一个元素，这个时候对应的时间复杂度就是最好情况时间复杂度。

最坏情况时间复杂度（worst case time complexity）

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

最好情况时间复杂度和最坏情况时间复杂度对应的都是极端情况下的代码复杂度，发生的概率其实并不大。

平均情况时间复杂度（average case time complexity）

平均情况时间复杂度就是平均情况下要遍历多少个元素的值吗？

平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。

我们先按照这样算一下：

• 要查找的变量 x 在数组中的位置，有 n+1 种情况：在数组的 0～n-1 位置中和不在数组中。
• 需要遍历的元素个数的平均值:我们把每种情况下查找需要遍历的元素个数累加起来，然后再除以 n+1

我们知道，时间复杂度的大 O 标记法中，可以省略掉系数、低阶、常量，所以，咱们把刚刚这个公式简化之后，得到的平均时间复杂度就是 O(n)。

结论是正确的但是，这样的分析方式是不严谨的，因为这 n+1 种情况，出现的概率并不是一样的。

• 要查找的变量 x，要么在数组里，要么就不在数组里。为了方便理解，我们假设在数组中与不在数组中的概率都为 1/2。
• 另外，要查找的数据出现在 0～n-1 这 n 个位置的概率也是一样的，为 1/n。所以，根据概率乘法法则，要查找的数据出现在 0～n-1中任意位置的概率就是 1/(2n)。

  这个值就是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。引入概率之后，前面那段代码的加权平均值为 (3n+1)/4。用大 O 表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是 O(n)。

  很多时候，我们使用一个复杂度就可以满足需求了。只有同一块代码在不同的情况下，时间复杂度有量级的差距，我们才会使用这三种复杂度表示法来区分。

均摊时间复杂度（amortized time complexity）

均摊时间复杂度就是一种特殊的平均时间复杂度

  大部分情况下，我们并不需要区分最好、最坏、平均三种复杂度。平均复杂度只在某些特殊情况下才会用到，而均摊时间复杂度应用的场景比它更加特殊、更加有限。

举个例子，有插入代码如下，用来插入数据：

1. 当数组不满的时候直接插入
2. 当数组满的时候计算数组元素的总和，并将数组的元素逻辑移除，将总和的值置入第一个元素。

 // array表示一个长度为n的数组 // 代码中的array.length就等于n int[] array = new int[n]; int count = 0; void insert(int val) { 
    if (count == array.length) { 
    int sum = 0; for (int i = 0; i < array.length; ++i) { 
    sum = sum + array[i]; } array[0] = sum; count = 1; } array[count] = val; ++count; } 

以上这段代码的最好，最坏，平均时间复杂度分析如下：

1. 最好的时间复杂度为O(1)即数组不满的时候直接插入；最坏的时间复杂度为O(n)j即数组满了，要求和再插入。
2. 加权平均的时间复杂度是O(n)：根据插入位置的不同，分为n种情况：1到n-1位置时间复杂度是1，n位置时间复杂度是n，这n+1种情况发生的概率都是一样的，所以时间复杂度为：

均摊时间复杂度的运用场景

1. 对一个数据结构进行一组连续操作中，大部分情况下时间复杂度都很低，只有个别情况下时间复杂度比较高
2. 而且这些操作之间存在前后连贯的时序关系（比如一个 O(n) 插入之后，紧跟着 n-1 个 O(1) 的插入操作）

摊还分析

遇到以上场景的时候，我们可以把这一组操作放在一起分析，看是否能看是否能将较高时间复杂度那次操作的耗时，平摊到其他那些时间复杂度比较低的操作上。

在能够应用均摊时间复杂度分析的场合，一般均摊时间复杂度就等于最好情况时间复杂度。

复杂度分析的应用–快排

1. 找到固定位置(这里取的是left边界的位置)的值(flag)应该放在的位置（当l=r的位置），将小于它的都放左边，大于它的都放右边
2. 将找到的位置放入固定值flag
3. 递归以上操作，排该位置左边的元素，排该位置右边的元素

class Solution { 
    public int[] sortArray(int[] nums) { 
    int left = 0; int right = nums.length-1; mySort(nums,left,right); return nums; } private void mySort(int[] nums, int left, int right) { 
    int l = left; int r = right; if(l<r){ 
    int flag = nums[l]; while(l<r){ 
    while(l<r&&nums[r]>=flag) r--; nums[l] = nums[r]; while(l<r&&nums[l]<flag) l++; nums[r] = nums[l]; } nums[l] = flag; mySort(nums,left,l); mySort(nums,l + 1, right); } } } 

但是以上公式我勉强看懂了但是记不住，所以贴出以下好理解的方式：

如果求平均时间复杂度：

若第一层的话就是n/2，n/2，若是第二层就是n/4,n/4,n/4,n/4这四部分，即n个元素理解上是一共有几层2^x=n，x=logn，然后每层都是n的复杂度，那么平均就是O(nlogn)的时间复杂度。