数据结构与算法 --时间复杂度分析（二）

数据结构和算法解决代码的“快”“省”，而时间、空间复杂度做为数据结构和算法的精髓，很直观说明了代码”多快“”多省“

一、为什么需要复杂度分析？

---

代码跑一遍，通过统计，监控，得到的算法执行的时间占用的内存大小叫事后统计法

事后统计法具有局限性：

• 测试结果非常依赖测试环境
• 测试结果受数据规模的影响很大

所以，我们需要一个不用具体的测试数据来测试，就可以粗略地估计算法的执行效率的方法

 

二、大O复杂度表示法

---

T(n) = O(f(n))

n表示数据规模的大小,f(n)表示每行代码的执行次数之和

所有代码的执行时间 T(n) 与每行代码的执行次数 n 成正比

大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是代码执行时间随数据规模增长的变化趋势，所以叫渐进时间复杂度，简称时间复杂度

 （当 n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了。

计算时间复杂度的方法：

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

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

如果 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.乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

T1(n)=O(f(n))，T2(n)=O(g(n))；那么T(n)=T1(n)*T2(n)=O(f(n))*O(g(n))=O(f(n)*g(n)).

 

三、几种常见的复杂度分析 

---

多项式阶：随着数据规模的增长，算法的执行时间和空间占用，按照多项式的比例增长。包括，
O(1)（常数阶）、O(logn)（对数阶）、O(n)（线性阶）、O(nlogn)（线性对数阶）、O(n^2)（平方阶）、O(n^3)（立方阶）

非多项式阶：随着数据规模的增长，算法的执行时间和空间占用暴增，这类算法性能极差。包括，
O(2^n)（指数阶）、O(n!)（阶乘阶

几种常见的多项式时间复杂度 ：

1、O(1)

O(1)只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。比如这段代码，即便三行，时间复杂度也是O(1)，而不是O(3)

 int i = 8;
 int j = 6;
 int sum = i + j;

只要代码的执行时间不随数据规模的n的增大而增大，那么代码的时间复杂度就为O(1).

一般只要算法中不存在循环，递归，无论代码上千行都是O(1)

2、O(logn)、O(nlogn)

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

我们只需要知道x的值，就知道执行多少次了 ，也就是求2的x次幂=n，x=log2n就是时间复杂度

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

显然就是O(log3n)

所有对数的时间复杂度都为logn    因为，log2n=log3n/log32=log23*log3n

根据乘法法则，如果一段代码的时间复杂度为O(logn)，循环执行n遍，时间复杂度就是O(nlogn)。O(nlogn)也是非常常见的时间复杂度，如归并排序，快速排序。

3. O(m+n)、O(m*n) 

这是两个数据规模的情况，我们无法事先评估哪个量级大，所以加法法则就不适用了，只能是O(m+n)。

但是乘法法则继续有效：T1(m)*T2(n) = O(f(m) * f(n))

 

四、空间复杂度

---

时间复杂度全称渐进时间复杂度，表示算法的执行时间随问题规模增大的变化趋势

类比，空间复杂度全称就是渐进空间复杂度，表示算法的存储空间与数据规模之间的增长关系

 

五：复杂度分析的4个概念

---

1.最坏情况时间复杂度：代码在最理想情况下执行的时间复杂度。

2.最好情况时间复杂度：代码在最坏情况下执行的时间复杂度。

3.平均时间复杂度：用代码在所有情况下执行的次数的加权平均值表示。

4.均摊时间复杂度：在代码执行的所有复杂度情况中绝大部分是低级别的复杂度，个别情况是高级别复杂度且发生具有时序关系时，可以将个别高级别复杂度均摊到低级别复杂度上。基本上均摊结果就等于低级别复杂度

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

• 最好、最坏时间复杂度

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

这段代码是在一个无序数组里查找变量x的位置，没有找到返回-1。时间复杂度为O(n)

由于我们查找一个数据，并不要每次都遍历数组，有可能中途找到，提前结束。我们来优化一下上面代码

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

 当第一个元素就是我们要找的，那么剩余n-1个元素就不需要遍历了，那么最好时间复杂度为O(1)。当数组中不存在x，那么就需要遍历整个数组，那么最坏时间复杂度就是O(n)。

• 平均情况时间复杂度

因为最好最好坏时间复杂度都是极端情况，发生几率小，为了更好的表示平均情况时间复杂度，我们引入另一个概念：平均情况时间复杂度，简称平均时间复杂度

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

 因此平均时间复杂度就是O(n)

由于n+1种情况出现的概率并不是一样的。为了方便理解，我们假设在数组中与不在数组中的概率都为1/2。要查找的数据出现在0~n-1这n个位置的概率为1/n。根据概率乘法法则，要查找的数据出现在0~n-1中任意位置的概率是1/2n。

这个值就是概率论中的加权平均值，也叫做期望。所以这段代码的加权平均时间复杂度仍然是O(n)

• 均摊时间复杂度

// 全局变量，大小为 10 的数组 array，长度 len，下标 i。
int array[] = new int[10]; 
int len = 10;
int i = 0;

// 往数组中添加一个元素
void add(int element) {
   if (i >= len) { // 数组空间不够了
     // 重新申请一个 2 倍大小的数组空间
     int new_array[] = new int[len*2];
     // 把原来 array 数组中的数据依次 copy 到 new_array
     for (int j = 0; j < len; ++j) {
       new_array[j] = array[j];
     }
     // new_array 复制给 array，array 现在大小就是 2 倍 len 了
     array = new_array;
     len = 2 * len;
   }
   // 将 element 放到下标为 i 的位置，下标 i 加一
   array[i] = element;
   ++i;
}

当i < len时, 即 i = 0,1,2,...,n-1的时候，for循环不走，所以这n次的时间复杂度都是O(1);

当i >= len时, 即 i = n的时候，for循环进行数组的copy，所以只有这1次的时间复杂度是O(n);

由此可知:
该算法的最好情况时间复杂度(best case time complexity)为O(1)
最坏情况时间复杂度(worst case time complexity)为O(n)

平均情况时间复杂度(average case time complexity)
第一种计算方式: (1+1+...+1+n)/(n+1) = 2n/(n+1) 【注: 式子中1+1+...+1中有n个1】,所以平均复杂度为O(1);
第二种计算方式(加权平均法，又称期望): 1*(1/n+1)+1*(1/n+1)+...+1*(1/n+1)+n*(1/(n+1))=1，所以加权平均时间复杂度为O(1);

第三种计算方式(均摊时间复杂度): 前n个操作复杂度都是O(1)，第n+1次操作的复杂度是O(n)，所以把最后一次的复杂度分摊到前n次上，那么均摊下来每次操作的复杂度为O(1)
 

六：题目

---

1.【2011年计算机联考真题】
设n是描述问题规模的非负整数，下面程序片段的时间复杂度是（）。

    x=2;
    while(x<n/2)
        x=2*x;

A. O(log2n)    B. O(n)    C. O(nlog2n)    D. O(n2)

  A
在程序中，执行频率最高的语句为“x=2*x”。设该语句共执行了 t次，则2t+1=n/2，故t=log2(n/2)-1=log2n-2，得 T(n)=O(log2n)。 

 

2.【2012年计算机联考真题】
求整数n (n>=0)阶乘的算法如下，其时间复杂度是（ ）。

int fact(int n){
     if (n<=l) return 1;
     return n*fact(n-1);
 }

A. O(log2n)    B. O(n)    C. O(nlog2n)     D. O(n2)

B
本题是求阶乘n!的递归代码，即n*(n-1)*...*1共执行n次乘法操作，故T(n)=O(n)。