复杂度分析

为什么需要复杂度分析？

有的人认为把代码跑一遍，通过统计、监控，就能得到算法执行的时间和占用的内存大小。为什么还要做时间、空间复杂度分析呢？

这种评估算法执行效率的方法是正确的，很多书籍称它为事后统计法。但是，它的局限性也很大。

1.测试结果非常依赖测试环境

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

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

大O复杂度表示法

算法的效率粗略地讲，就是算法代码执行的时间。

栗子：

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

这段代码很简单，求1,2,3…n的累加和。现在我们来估算一下这段代码的执行时间。

第2、3行代码分别需要一个t的执行时间，第4、5行都运行了n遍，所以需要2n*t的执行时间，所以这段代码总的执行时间就是(2n+2)*t。可以得到一个规律，所有代码的执行时间T(n)与每行代码的执行次数n成正比。

我们可以把这个规律总结成一个公式:

这里解释一下公式的涵义。其中T(n)表示代码执行的时间；n表示数据规模的大小；f(n)表示每行代码执行的次数总和。因为这是一个公式，所以用f(n)来表示。公式中的O，表示代码的执行时间T(n)和f(n)表达式成正比。

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

时间复杂度分析

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 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的规模无关，可以忽略不计。因为它本身对增长趋势并没有影响。第二段和第三段代码的时间复杂度分别是O(n)和O(n^2)。综合这三段代码的时间复杂度，我们取其中最大的量级。所以，整段代码的时间复杂度就是O(n ^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.乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

栗子：

    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^2)。

这三种复杂度的分析技巧无需死记硬背，关键在于“熟练”。多看案例，多分析。

疑惑？？？栗子三的用途

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

多项式量级

常量阶:O(1)

对数阶:O(logn)

线性阶:O(n)

线性对数阶:O(nlogn)

平方阶:O(n ^2)

非多项式量级

指数阶:O(2 ^n)

阶乘阶:O(n!)

我们把时间复杂度为非多项式量级的算法问题叫做NP(Non-Deterministic Polynomial，非多项式)问题。

当数据规模n越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无线增长。所以，非多项式时间复杂度的算法其实是非常低效的算法。因此，在这里跳过NP时间复杂度。主要来看几种常见的多项式时间复杂度。

1.O(1)

首先你必须明确一个慨念，O(1)只是常量级时间复杂度的一种表示方法，并不是指执行性了一行代码。只要代码的执行时间不随n的增大而增长，那么这样代码的时间复杂度我们都记作O(1)。

换句话说，一般情况就，只要算法中不存在循环语句
递归语句，即使有成千上万行的代码，其时间复杂度也是O(1)。

2.O(logn)、O(nlogn)

对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。我们来看一个例子。

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

根据我们前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。所以，我们只要能计算出这行代码执行了多少次，就知道整段代码的时间复杂度。

从代码中可以看出，变量i的值从1开始取，每循环一次就乘以2。当大于n时，循环结束。实际上变量i的取值就是一个等比数列。如果我把它一个一个列出来，就应该是这个样子的：

所以我们只要知道x的值是多少，就知道这行代码执行的次数了。通过2^x=n求解x这个问题我们高中就学过了，就不多说了。x=log2 ^n，所以这段代码的时间发展度就是O(log2 ^n)。

我们知道，对数之间是可以相互转换的，log3 ^n 就等于 log3 ^2 * log2 ^n，所以O(log3 ^n)=O(C* log2 ^n)，其中C是一个常量，所以可以忽略。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为O(logn)。

如果可以理解O(logn)，那么O(nlogn)就很容易理解了。还记得我们前面讲到的乘法法则吗？如果一段代码的时间复杂度是O(logn)，我们循环执行n遍，时间复杂度就是O(nlogn)了。而且，O(nlogn)。也是一种常见的算法时间复杂度。比如，归并排序、快速排序的时间复杂度都是O(nlogn)。

3.O(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;
    }

这段代码中有m和n两个数据规模。我们无法事先评估m和n谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中的一个。所以，上面代码的执行时间复杂度就是O(m+n)。

针对这种情况，原来的加法法则就不正确了，我们需要将加法法则改为：T1(m)+T2(n)=O(f(m)+g(n))。但是乘法法则则继续有效：T1(m)*T2(n)=O(f(m)+f(n))

空间复杂度分析

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

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

时间复杂度的细化

1.最好、最坏情况时间复杂度

最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。

最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。

先看一个栗子：

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

这段代码想要查找x在数组中的位置，用前面学习的分析方法计算这段代码的时间复杂度是O(n)。但是，我们并不需要每次都把整个数组遍历一遍，因为中途找到x就可以跳出循环。所以，前面讲的分析方法就无法解决这个问题。

我们要查找的变量x可能出现在数组的任意位置。如果数组中第一个元素正好是要查找的变量x，那就不需要继续遍历剩下的n-1个数据了，那时间复杂度就是O(1)。但如果数组中不存在变量x，那么我们就需要把整个数组都遍历一遍，时间复杂度就成了O(n)。所以，不同的情况下，这段代码的时间复杂度是不一样的。所以这段代码的最好、最坏情况时间复杂度分别是O(1)、O(n)。

2.平均情况时间复杂度

因为最好情况时间复杂度和最坏情况时间复杂度对应的都是极端情况下的代码复杂度，所以发生的概率其实并不大。为了更好地表示平均情况下的复杂度，平均(情况)时间复杂度出现了。

我们还是借助查找变量x的例子来解释。要查找变量x在数组的位置，有n+1种情况：在数组的0~n-1位置中和不在数组中。我们把每种情况下，查找需要遍历的元素个数累加起来，再除以n+1，就可以得到需要遍历的元素个数的平均值，即：

时间复杂度的大O表示法中可以省略掉系数、低阶、常量，所以，这个公式简化后得到的的平均时间复杂度就是O(n)。

这个结论虽然是正确的，但是计算过程还有些问题。因为我们刚才说到的n+1种情况出现的概率是不一样的。所以上面的平均值还不够准确。

我们知道，要查找的变量x，要么在数组里，要么不在数组里。这两种情况对应的概率统计起来很麻烦，为了方便理解，我们假设在数组中与不在数组中的概率都是1/2。另外，要查找的数据出现在0~ n-1这n个位置的概率也是一样的，为1/n。所以，根据概率乘法法则，要查找的数据出现在0~n-1中任意位置的概率就是1/(2n)。

如果我们把各种情况发生的概率考虑进去，那平均复杂度的计算过程就变成了这样：

这个值就是概率论中的加权平均值，也叫期望值，所以平均时间复杂度的全称应该叫做加权平均时间复杂度或者期望时间复杂度。

用大O表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍是O(n)。

实际上，在大多数情况下，我们并不需要区分最好、最坏、平均情况时间复杂度三种情况。很多时候，我们使用一个复杂度就可以满足需求了。只有同一块代码在不同的情况下，时间复杂度由量级的差距，我们才会使用这三种复杂度表示法区分。

3.均摊时间复杂度

学习了王争老师的《数据结构与算法之美》，根据课程内容整理的笔记