大白话数据结构与算法(1)：时间复杂度

---

前言

    算法与数据结构是程序员必须掌握的一个点，走今天开始开一个它的坑，我将会用JavaScript+最通俗易懂的大白话从头到尾梳理一遍。

---

提示：以下仅代表个人观点，如有明显错误欢迎指正。

时间复杂度

名词解释

    时间复杂度即是指一段代码执行的效率（速度与所需时间）。

计算方法

    在说方法之前，我们先来看两段非常简单的求和代码：

//要求：传入一个n,求1+2+3+4+……+n总和是多少

//方法1
function computeA(n){
   let sum = 0
   for(let i = 1;i <= n;i++){
       sum+=i
   }
   return sum
}

//方法2
function computeB(n){
   return n === 0 ? 1 : (n+1) * (n/2)
}

//调用
computeA(100) //5050
computeB(100) //5050

    通过上面的代码我们不难发现虽然computeA和computeB的结果都是完全正确的，但无论走代码量和时间复杂度来说computeB是比computeA更好的，代码量就不说了，一看就知道，但是时间复杂度我们该如何计算呢？

大O表示法

    通过大O表示法，我们就可以大致的得到一个算法的时间复杂度，常用 O(1), O(n), O(logn), O(nlogn), O(n²) 来表示对应算法的时间复杂度。

    由图可知，执行效率从小到大依次为 O(1)<O(logn)<O(n)<O(nlogn)<O(n²)

    下面我将把这些常见的复杂度计算方式通过代码来进行讲解。

O(1)

    O(1)作为效率最快的算法，那么这种算法具有的特点即是不会被传入的参数所影响，就比如刚才我们见过的求和算法中的第二种方法:

function computeB(n){
   return n === 0 ? 1 : (n+1) * (n/2) 
}

    可能看到这里，你都还是对大O表示法非常模糊，其实它的计算方法非常简单，比如上面的computeB这个方法为什么是O(1)，是因为它整个算法所执行的语句次数是一个常量，而且无论传入的参数是多少，算法的执行语句次数不会改变。
     如果还是不能理解，没关系，带着这个思路我们继续往下看。

function computeB(n){
   if(n === 0) return 1
   let sum = (n+1) * (n/2)
   return sum
}

     在这里我稍微将computeB方法改了改，其实只是将三元运算符拆开了，那么这里他的算法复杂度为多少呢？答案依然是O(1)，因为它整个算法所执行的语句次数是一个常量且不会随着形参大小所变化。原先它整个方法的语句只有一条return，现在变成了4条语句，虽然语句变多了，但无论n是10，100，还是1000000，它的执行语句条数都是固定的，永远都只会执行4条语句，而这种常量性复杂度，就统称为O(1)。

O(n)

function compute(n){
   let sum = 0
   for(let i = 0;i < n;i++){
       sum+=j
   }
   return sum
}

     为了更容易的去理解时间复杂度，我先把比较好懂的O(n)例举出来，如上述代码，这个就是一个O(n)复杂度的标准代码。

   let sum = 0

     我们带着上面O(1)的思路来拆开看这个算法，首先这条上面语句，因为它无论如何都只执行一次，所以它的复杂度为O(1)

   for(let i = 0;i < n;i++){
       sum+=j
   }

     我们接着往下看，到了这个for循环这里的时候，就到了决定O(n)的关键点，这个地方的复杂度为n，因为这里的for循环条件是i < n，如果n为1那只执行一次，可是n为10000甚至1000000呢？这里的执行次数完全被形参n所影响，所以这里的复杂度为O(n)。

   return sum

     这里的复杂度为O(1)，因为只是return了一个参数回去，只执行一次。

     所以当我们把三个执行次数加起来，那就是1 + n + 1，在大O表示法中，常量值可以约掉，即该算法复杂度就为 O(n)，逻辑比较灵敏的朋友可能已经有所收获了，其实O(n)和O(1)唯一的区别就是看算法中是不是有会被参数影响的且不确定执行次数的语句。

O(n²)

function compute(n){
   let sum = 0  //O(1)
   for(let i = 0;i < n;i++){ //O(n)
      for(let j = 0;j < n;j++){  //O(n)
          sum+=j
      }
   }
   return sum  //O(1)
}

     O(n)看完了后，我们来看O(n²)，如果你已经理解了之前的内容，那么看到上面这个算法的时候你可能自己就能懂了，O(n²)无非就是在满足O(n)的语句中再嵌套一个满足O(n)条件的语句，这样每执行一次外层语句，里面的语句都会执行n次，而最终会执行n²次，这就是O(n²)复杂度。

O(logn)

function logN(n){
  let count = 1
  while (count < n){
    count *= 2 //count*=2等于count = count * 2
  }
}

     O(logn)容易与O(n)混淆，因为两者都是受参数n影响且循环次数未知的算法，不过区分起来也很简单，在O(n)中，我们满足O(n)条件的语句必定会执行n次，而在O(logn)中，执行次数会因为循环条件的改变而却不够n次。
     比如上面这段代码，在每次循环的时候作为循环条件之一的变量count会被乘以2，所以最终执行的次数不是n次，而是log2n次，不过最终表示法还是写O(logn)，把2去掉，如果不懂log是什么意思的朋友可以自行上网查下。

O(n logn)

function nLogN(n){
  let count = 1
  for(let i = 0;i < n;i++){ //O(n)
    while (count < n){  //O(logn)
      count *= 2 //count*=2等于count = count * 2
    }
}

     O(n logn)与O(n²)原理一样，外层如果嵌套了一个满足O(n)的语句，且里面的满足O(logn)的条件，把时间复杂度相乘 n * logn 就可以得出来这个算法复杂度为O(logn)。

总结

     至此，常见的时间复杂度就大概解释了一遍，不过举的例子都是非常简单的，而算法中通常都不会出现这么简单的案例，所以还需要多做多练才能慢慢理解。希望这篇文章对你有所帮助，如有疑问可以联系我或者留言，我们下个文章见。