数据结构与算法之复杂度分析

其实，只要讲到数据结构与算法，就一定离不开时间，空间复杂度分析。复杂度分析时整个算法学习的精髓，只要掌握了它，数据结构和算法的内容基本上就掌握了一半。

*一. 为什么需要复杂度分析

你可能会有些疑惑，我把代码跑一遍，通过统计，监控就能得到算法的执行时间和占用的内存大小。为什么还要做时间和空间复杂度分析呢？这种分析方法能比我实实在在跑一遍得到的数据更加准确么？

首先，这种方式是正确的，这种方法也叫事后统计法，但这种统计方法有很大的局限性。

1. 测试结果非常依赖测试环境。
2. 测试结果受数据规模的影响很大。
   所以我们需要一个不用具体的测试数据赖测试，就可以粗略地估计算法的执行效率的方法。

二. 大O复杂度分析法

所有代码的执行时间（T(n)）与每行代码的执行次数n成正比。我们将这个规律总结成一个公式：
T(n)=O(f(n))
其中T(n)是代表代码的执行时间；n表示数据规模的大小；f（n）是每行代码执行次数的总和。公式的O表示代码的执行时间和代码执行次数总和成正比。这就是大O时间复杂度表示法
大O时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模的增长的变化趋势，所以也叫做渐进时间赋值度，简称时间复杂度。对于f（n）这个函数，我们通常也只需要关注量级最大的那一个，比如说O(n² + 2n)，由于随着n的增大，2n慢慢可以忽略不计，我们就可以将其简化为O（n²)。
实用小技巧

1. 只关注循环次数最多一段代码。
2. 加法法则：总复杂度等于量级最大的那段代码的复杂度。
3. 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积（T(n)=T1(n)T2(n)=O(nn)=O(n²)）。

三. 常见的时间复杂度实例分析

O(logn)
例如：

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

根据我们前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。所以，我们只要能计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。还记得我们高中学过的等比数列吗？实际上，变量 i 的取值就是一个等比数列。所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。通过 2x=n 求解 x 这个问题我们想高中应该就学过了，我就不多说了。x=log2n，所以，这段代码的时间复杂度就是 O(log2n)。我们知道，对数之间是可以互相转换的，log3n 就等于 log32 * log2n，所以 O(log3n) = O(C * log2n)，其中 C=log32 是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，O(log2n) 就等于 O(log3n)。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”。

四. 空间复杂度

时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。类比一下，空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系。

五. 最好时间复杂度，最坏时间复杂度，平均情况时间复杂度，均摊时间复杂度

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

在这段代码中，如果数组第一个

1. 最好时间复杂度：
   元素正好是要查找的变量x，那时间复杂度则为O(1)。

2. 最坏时间复杂度
   最坏时间复杂度为O(n)

3. 平均情况时间复杂度（加权平均时间复杂度/期望时间复杂度）
   在上述代码中，我们需要查找的那个数可能出现在数组中的任何一个位置，也可能不在数组中， 共有n+1中可能性，我们可以列出：

但其实上面的计算过程还有一些问题，这个数要么出现在数组中，要么不在数组中，各占1/2的可能性；讨论在数组中的1/2可能性时，考虑到出现在每一个位置上的可能性均为1/n；讨论不在数组中的可能性时，可能性为1。列出：

4.均摊时间复杂度

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

我们先来对比一下这个 insert() 的例子和前面那个 find() 的例子，你就会发现这两者有很大差别。 首先，find() 函数在极端情况下，复杂度才为 O(1)。但 insert() 在大部分情况下，时间复杂度都为 O(1)。只有个别情况下，复杂度才比较高，为 O(n)。这是 insert()第一个区别于 find() 的地方。

我们再来看第二个不同的地方。对于 insert() 函数来说，O(1) 时间复杂度的插入和 O(n) 时间复杂度的插入，出现的频率是非常有规律的，而且有一定的前后时序关系，一般都是一个 O(n) 插入之后，紧跟着 n-1 个 O(1) 的插入操作，循环往复。所以，针对这样一种特殊场景的复杂度分析，我们并不需要像之前讲平均复杂度分析方法那样，找出所有的输入情况及相应的发生概率，然后再计算加权平均值。

针对这种特殊的场景，我们引入了一种更加简单的分析方法：摊还分析法，通过摊还分析得到的时间复杂度我们起了一个名字，叫均摊时间复杂度。那究竟如何使用摊还分析法来分析算法的均摊时间复杂度呢？我们还是继续看在数组中插入数据的这个例子。每一次 O(n) 的插入操作，都会跟着 n-1 次 O(1) 的插入操作，所以把耗时多的那次操作均摊到接下来的 n-1 次耗时少的操作上，均摊下来，这一组连续的操作的均摊时间复杂度就是 O(1)。这就是均摊分析的大致思路

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