数据结构和算法之时间复杂度

前言

       学习数据结构和算法，并不是为了死记硬背几个知识点。我们的目的是建立时间复杂度、空间复杂度意识，写出高质量的代码，能够设计基础架构，提升编程技能，训练逻辑思维，积攒人生经验，以此获得工作回报，实现你的价值，完善你的人生。
       掌握了数据结构与算法，你看待问题的深度，解决问题的角度就会完全不一样。因为这样的你，就像是站在巨人的肩膀上，拿着生存利器行走世界。数据结构与算法，会为你的编程之路，甚至人生之路打开一扇通往新世界的大门。

对数据结构和算法，要学习它的来历、自身的特点、适合解决的问题和实际的应用场景。
最常用的、最基础数据结构与算法：
10 个数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie 树；
10 个算法：递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。

我们需要一个不用具体测试就可以粗略地估计算法的执行效率的方法。这就是时间、空间复杂度分析方法，即大 O 复杂度表示法。

1 时间复杂度

       所有代码的执行时间 T(n) 与每行代码的执行次数 n 成正比，因此我们用T(n) = O(f(n))来表示代码执行时间，即大 O 时间复杂度表示法。
       大O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势。n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了。

1.1 分析方法

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

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

其中第 2、3 行代码都是常量级的执行时间，与 n 的大小无关，所以对于复杂度并没有影响。循环执行次数最多的是第 4、5 行代码，所以这块代码要重点分析。前面我们也讲过，这两行代码被执行了 n 次，所以总的时间复杂度就是 O(n)。

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

int cal(int n) {
   int sum_1 = 0;
   int p = 1;
   for (; p < 100; ++p) {
     sum_1 = sum_1 + p;
   }

   int sum_2 = 0;
   int q = 1;
   for (; q < n; ++q) {
     sum_2 = sum_2 + q;
   }
 
   int sum_3 = 0;
   int i = 1;
   int 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_1、sum_2、sum_3。我们可以分别分析每一部分的时间复杂度，然后把它们放到一块儿，再取一个量级最大的作为整段代码的复杂度。
       第一段的时间复杂度是多少呢？这段代码循环执行了 100 次，所以是一个常量的执行时间，跟 n 的规模无关。这里再强调一下，即便这段代码循环 10000 次、100000 次，只要是一个已知的数，跟 n 无关，照样也是常量级的执行时间。当 n 无限大的时候，就可以忽略。尽管对代码的执行时间会有很大影响，但是回到时间复杂度的概念来说，它表示的是一个算法执行效率与数据规模增长的变化趋势，所以不管常量的执行时间多大，我们都可以忽略掉。因为它本身对增长趋势并没有影响。
       那第二段代码和第三段代码的时间复杂度是 O(n) 和 O(n²)。综合这三段代码的时间复杂度，我们取其中最大的量级。所以整段代码的时间复杂度就为 O(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;
    }
   

       我们单独看 cal() 函数。假设 f() 只是一个普通的操作，那第 4～6 行的时间复杂度就是T1(n) = O(n)。但 f() 函数本身不是一个简单的操作，它的时间复杂度是 T2(n) = O(n)，所以，整个 cal() 函数的时间复杂度就是，T(n) = T1(n) * T2(n) = O(n*n) = O(n²)。

1.2 常见时间复杂度

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

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

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

   其实相当于求解 2^x=n 中 x的值， 也就是x=log₂n，所以这段代码的时间复杂度就是 O(log₂n)。

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

       很简单就能看出来，这段代码的时间复杂度为 O(log₃n)。实际上，不管是以 2 为底、以 3 为底，还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 O(logn)。为什么呢？我们知道，对数之间是可以互相转换的，log₃n 就等于 log₃2 * log₂n，所以 O(log₃n) = O(C * log₂n)，其中 C=log₃2 是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，O(log₂n) 就等于 O(log₃n)。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。

3. O(n)

4. O(nlogn)
   像快排的时间复杂度就是O(nlogn)。

   public static void quickSort(int[] arr, int left, int right) {
           // 结束递归的条件
           if (left > right) {
               return;
           }
   
           int temp;
           int i = left;
           int j = right;
           int baseNum = arr[left];
           //开始循环寻找
           while (i != j) {
               while (j > i && arr[j] > baseNum) {
                   j--;
               }
               while (i < j && arr[i] <= baseNum) {
                   i++;
               }
               //此时说明停下来,交换两个数位置
               temp = arr[i];
               arr[i] = arr[j];
               arr[j] = temp;
           }
           //跳出while循环说明两个指针相遇,此时基准数归位
           arr[left] = arr[i];
           arr[i] = baseNum;
           //继续递归调用
           quickSort(arr, left, i - 1);
           quickSort(arr, i + 1, right);
       }
   

5. n²、n³、n^k等k次方阶

6. 指数阶O(2ⁿ) 、 阶乘阶O(n!)
   这两个属于非多项式量级，我们把时间复杂度为非多项式量级的算法问题叫作 NP（Non-Deterministic Polynomial，非确定多项式）问题。非多项式时间复杂度的算法其实是非常低效的算法，一般很少遇到。

7. O(m+n)、O(m*n)
   从下面代码中可以看出，m 和 n 是表示两个数据规模。我们无法事先评估 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;
   }
   

2.3 最坏时间复杂度、最好时间复杂度、平均时间复杂度

       顾名思义，最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。同理，最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。
       而平均时间复杂度实际上在概率论中，应该叫加权平均时间复杂度或者期望时间复杂度。很多时候，我们使用一个复杂度就可以满足需求了。只有同一块代码在不同的情况下，时间复杂度有量级的差距，我们才会使用这三种复杂度表示法来区分。
       均摊时间复杂度，对一个数据结构进行一组连续操作中，大部分情况下时间复杂度都很低，只有个别情况下时间复杂度比较高，而且这些操作之间存在前后连贯的时序关系，这个时候，我们就可以将这一组操作放在一块儿分析，看是否能将较高时间复杂度那次操作的耗时平摊到其他那些时间复杂度比较低的操作上。而且，在能够应用均摊时间复杂度分析的场合，一般均摊时间复杂度就等于最好情况时间复杂度。

2.空间复杂度

表示算法的存储空间与数据规模之间的增长关系

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(n²)，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。