数据结构与算法的重温之旅（一）——复杂度分析

本系列全部文章的代码都是用JavaScript实现，之因此用JavaScript实现是由于它能够直接在浏览器宿主中运行代码，即在浏览器中按f12打开控制台，选择console按钮，在下面空白的文本框把本例的代码黏贴上去回车便可运行。方便各位同窗学习和调试。

最近刷leetCode刷到后面medium级别的题目的时候就越力不从心，因而乎去极客时间那里买了一门数据结构与算法的课来学习一下，本刊是记录本身在这门课程的笔记，若有错误，劳烦勘正。

在讲解复杂度分析以前，咱们先要知道为何咱们写程序的时候须要算法与数据结构。可能有些人以为本身随便撸一段代码，保证业务流畅运行不报错就能够了，其实这样的认知是十分肤浅的。你目前的解决方法只是解决了你目前测试当中所遇到的问题，当在复杂的生存环境中，有可能遇到的数据十分的庞大，一些你本来觉得完美的代码可能在这复杂的环境中挤占太多的服务器资源或客户端资源，设置直接致使服务器宕机或者客户端挂掉，因此咱们有必要用算法与数据结构来优化咱们的代码。那什么是算法，什么是数据结构呢？按照个人理解：数据结构是数据的存储状态，算法则是对数据的操做方法。认知这一点很重要，不少人觉得算法就是数据结构，数据结构就是算法，其实他们两个不是相等关系，而是相关联的关系，做用于他们之间的其实就是数据，数据结构和算法谁也不能脱离谁单独使用。

讲到这里咱们就进入正体，咱们为何要分析一个算法与数据结构的复杂度呢，咱们之因此用算法与数据结构是为了提升程序的性能，程序的哪方面的性能获得提高呢？答案是他的所用时间和所占空间（也就是所占的服务资源），换句话来讲，咱们用算法与数据结构的目的是要更快更省。

那咱们如何分析一个算法是否更快更省呢，传统上有一个方法是过后统计法，即经过统计和监控获得算法执行所用的时间和占用的内存大小，可是这种方法十分的不许确，哪些因素会影响呢，主要是下面这些状况：

1.测试结果很是依赖测试环境

在测试的过程当中若是你的机器硬件设备很好的话，测试得出的数据可能很好看，可是若是是换了一个老旧的机器的话，可能得出的数据跟好的机器得出的数据差异很大。

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

有些数据若是数量不多用算法是看不出来不一样算法之间有什么优点区别。在排序算法中，在同等状况下，好比数据是有序的状况下，用冒泡排序所用的时间设置比用快速排序的时间还要少。

通过上面的例子，因此咱们必须经过一个科学的方法来比较各个算法之间的复杂度，这种方法咱们称之为大O复杂度表示法。下面咱们来分析一个算法的时间复杂度。

算法的执行效率其实粗略的讲是代码执行所要花费的时间，那咱们应该如何看出一个算法所花的时间呢，下面贴个代码来举例子：

function test (val) {
    let sum = 0;
    let a = 1
    for (; a < val; a++) {
        sum = sum + 1
    }
    return sum
}复制代码

咱们在估算程序每一个步骤所用的时间时，假设每一步所用的时间都是相等的，都为unit_time，在这个假设的基础上，咱们来计算一下该程序所用的时间。第 二、3 行代码分别须要 1 个 unit_time 的执行时间，第 四、5 行都运行了 n 遍，因此须要 2n*unit_time 的执行时间，因此这段代码总的执行时间就是 (2n+2)*unit_time。能够看出来，全部代码的执行时间 T(n) 与每行代码的执行次数成正比。

同理，按照这个思路，咱们在拿一个程序来举例：

function test (val) {
    var sum = 0
    var i = 1
    var j = 1
    for (; i <= val; i++) {
        j = 1
        for (; j <= val; j++) {
            sum = sum + i * j
        }
    }
}复制代码

运用刚才的思路，第 二、三、4 行代码，每行都须要 1 个 unit_time 的执行时间，第 五、6 行代码循环执行了 n 遍，须要 2n * unit_time 的执行时间，第 七、8 行代码循环执行了 遍，因此须要 2n* unit_time 的执行时间。因此，整段代码总的执行时间 unit_time。尽管咱们不知道 unit_time 的具体值，可是经过这两段代码执行时间的推导过程，咱们能够获得一个很是重要的规律，那就是，全部代码的执行时间 T(n) 与每行代码的执行次数 n 成正比。也就是下面所要说的大O表示法：。

我来具体的解释一下这个公式：其中，T(n) 咱们已经讲过了，它表示代码执行的时间；n 表示数据规模的大小；f(n) 表示每行代码执行的次数总和。由于这是一个公式，因此用 f(n) 来表示。公式中的 O，表示代码的执行时间 T(n) 与 f(n) 表达式成正比。因此第一个例子中的和第二个例子中的，这就是大O时间复杂度表示法。。大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增加的变化趋势，因此这也叫渐进时间复杂度（asymptotic time complexity），简称时间复杂度。当咱们的变量n很大的时候，其实在公式中低阶、常量和系数三个部分并不会左右整个增加趋势，因此咱们能够把他们忽略，记录最大的量级就能够了，因此上面两个实例的时间复杂度为：和。

如今咱们按照理论，进一步的说明比较实用判断时间复杂度的方法：

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

刚刚有讲，大 O 这种复杂度表示方法只是表示一种变化趋势。咱们一般会忽略掉公式中的常量、低阶、系数，只须要记录一个最大阶的量级就能够了。因此，咱们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就能够了。这段核心代码执行次数的 n 的量级，就是整段要分析代码的时间复杂度。如第一个代码例子里，第二、3行都是常量级的运行时间，与n无关，咱们能够忽略他们的用时，而第四、5行则是与n相关，整个程序当中执行次数最多的代码，这两行代码在上面有说过执行了n次，因此时间复杂度为O(n)。

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

以下面的这段代码：

function test(n) {
   let sum_1 = 0;
   let p = 1;
   for (; p < 100; ++p) {
     sum_1 = sum_1 + p;
   }

   let sum_2 = 0;
   let q = 1;
   for (; q < n; ++q) {
     sum_2 = sum_2 + q;
   }
 
   let sum_3 = 0;
   let i = 1;
   let 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;
 }
复制代码

这个代码其实分红了三份，分别是求sum_一、sum_2和sum_3，咱们把他们的时间复杂度放在一块儿比较，而后再取时间复杂度最大的做为整个代码的复杂度。按照代码来分析，首先第一块sum_1是进行100次的循环运算，这个只是一个常量级的运算时间，和n无关。第二块代码则进行了n次的循环运算，则时间复杂度为O(n)。第三块代码则进行了n的平方次循环运算，获得的时间复杂度为，因此经过上面的比较，咱们能够获得该程序的时间复杂度为，也就是说总的时间复杂度等于量级最大的那段代码的时间复杂度。抽线成具体公式则是：

若是，则

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

讲完了加法法则，其实你们能够经过发散思惟猜到乘法法则的公式是什么样的，乘法法则的公式以下所示：，则。按照公式，若是f(n)等于n，g(n)等于n的平方的话，那最后的T(n)则等于n的立方。下面举例来佐证：

function test(n) {
   let ret = 0; 
   let i = 1;
   for (; i < n; ++i) {
     ret = ret + f(i);
   } 
 } 
 
 function f(n) {
  let sum = 0;
  let i = 1;
  for (; i < n; ++i) {
    sum = sum + i;
  } 
  return sum;
 }
复制代码

咱们单独看 test() 函数。假设 f() 只是一个普通的操做，那第 4～6 行的时间复杂度就是，T1(n) = O(n)。但 f() 函数自己不是一个简单的操做，它的时间复杂度是 T2(n) = O(n)，因此，整个 cal() 函数的时间复杂度就是，T(n) = T1(n) * T2(n) = O(n*n) = 。

其实上面的这三种方法不须要死记硬背，只要多运用多实践就能够记到心中。时间复杂度分为多项式和非多项式，非多项式只有和，多项式有不少种，下面来详细的讲一下常见的时间复杂度：

1.O(1)时间复杂度

O(1)表示的是n是个常量，并非说代码只有一行，而是指代码里面没有递归、循环语句的时候，即便代码有成千上万行，时间复杂度仍然是个常量，和n无关。

2.O(logn)和O(nlogn)时间复杂度

这两个时间复杂度表示的是一个对数阶，比较常见这种对象阶的时间复杂度出在二分查找那里，下面以一个简单的例子来举例O(logn)时间复杂度

var i = 1
 var n = 10
 while (i <= n)  {
   i = i * 2;
 }
复制代码

在这个例子当中，这个循环只需运行三次便可，这个代码有点像咱们高中时候学的等比数列，i每次都乘以2，这样的话咱们就获得公式，利用高中学过的对数只是，咱们获得，因此这里的时间复杂度是。不过在这里咱们就有疑问了，为何不是时间复杂度，而是logn的时间复杂度呢。在数学上，咱们能够对对数提取公因式，好比咱们如今有一个的数，提取公因式得：，咱们在上面有说过常数是能够省略的，因此获得的是logn。而nlog则更简单，它是经过在上面再加一层循环，利用上面说到的乘法原则所得而成。

3.O(n+m)和O(n*m)时间复杂度

当一个代码块里面有两个循环体，而且两个循环体都是至关于不一样的变量的时候，这个时间复杂度就由两个数据来决定的了。例子以下：

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

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

  return sum_1 + sum_2;
}
复制代码

在这里，两个代码块里的循环是分别相对于m和n的，因此咱们这里要将上面的加法原则进一步的修改，原来的加法原则是创建在循环都是对应同一个n的时候取时间复杂度最大的这一个，而这里因为没法判断哪个的时间复杂度最大因此只能让他们相加：。而O(n*m)是利用乘法原则，因此结论没变。

4.O(n!)和时间复杂度

这两个时间复杂度区别与以前提过的时间复杂度，这里的时间复杂度都是非多项式，因为时间消耗太大，通常比较少用到这些的时间复杂度。

在讲完了时间复杂度以后，下面将空间复杂度就简单不少。空间复杂度的全称是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增加关系。以下例子：

function print(n) {
  var i = 0;
  var a = new Array(n);
  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 的 int 类型数组，除此以外，剩下的代码都没有占用更多的空间，因此整段代码的空间复杂度就是 O(n)。空间复杂度的常见类型就O(1)、O(n)和，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。并且，空间复杂度分析比时间复杂度分析要简单不少。因此，对于空间复杂度，掌握刚我说的这些内容已经足够了。

最后以一幅时间复杂度的图来总结一下常见的时间复杂度：

​

下一篇文章：数据结构与算法的重温之旅（二）——复杂度进阶分析​​​​​​​

延伸阅读：数据结构与算法的重温之旅（番外篇1）——谈谈斐波那契数列​​​​​​​