复杂度分析是整个算法学习的精髓，只要掌握了它，数据结构与算法的内容基本上就掌握了一半。

大O复杂度表示法

算法的执行效率，粗略地讲，就是算法代码执行的时间。但是，如何在不运行代码的情况下，用“肉眼”得到一段代码执行时间呢？这里有段非常简单的代码，求1,2,3...n的累加和。一起来估算一下这段代码的执行时间。

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

从CPU的角度来看，这段代码的每一行都执行着类似的操作：读数据-运算-写数据 。尽管每行代码对应的CPU执行的个数、执行的时间都不一样，但是，我们这里只是粗略估计，所以可以假设每行代码执行的时间都一样，为unit_time。在这个假设的基础上，计算这段代码的总执行时间。其中第2、3行代码分别需要1个unit_time的执行时间，第4、5行都运行了n遍，所以需要2n*unit_time的执行时间，所以这段代码的总执行时间是(2n+2)*unit_time。按照这个分析思路，再来看看下面这段代码。

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

依旧假设每行执行时间是unit_time。可以计算出这段代码的总执行时间T(n) =(2n*n+2n+3)*unit_time。

因此所有代码的执行时间T(n)与每行代码的执行次数n成正比。 即大O时间复杂度表示法：

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

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

时间复杂度分析方法

只关注循环执行次数最多的一段代码
加法法则：总复杂度等于量级最大的那段代码的复杂度
乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

几种常见时间复杂度实例分析

1. O(1)

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

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

2. O(log(n))、 O(nlog(n))

对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。举例说明：

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

根据上文的复杂度分析方法可知，计算出第三行代码被执行了多少次，就知道整段代码的时间复杂度。从这段代码可以看出，变量i的取值从1开始取，每循环一次就乘以2，当大于n时，循环结束。即：变量i的取值是一个等比数列。只要知道x是多少，就知道这行代码执行的次数了， $x=log2(n)$ ，基于前面的一个理论：在采用大O标识复杂度的时候，可以忽略系数，因此在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为O(logn)。

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(n2 )，像O(logn)、O(nlogn)这样的对数阶复杂度平时都⽤不到。⽽且，空间复杂度分析⽐时间复杂度分析要简单很多。

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

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

为了表示代码在不同情况下的不同时间复杂度，我们需要引⼊三个概念：最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度。

最好情况时间复杂度就是，在最理想的情况下，执⾏这段代码的时间复杂度。就像我们刚刚讲到的，在最理想的情况下，要查找的变量x正好是数组的第⼀个元素，这个时候对应的时间复杂度就是最好情况时间复杂度。 最坏情况时间复杂度就是，在最糟糕的情况下，执⾏这段代码的时间复杂度。就像刚举的那个例⼦，如果数组中没有要查找的变量x，我们需要把整个数组都遍历⼀遍才⾏，所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度。

平均情况时间复杂度

借助刚刚查找变量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)。因此，前⾯的推导过程中存在的最⼤问题就是，没有将各种情况发⽣的概率考虑进去。如果我们把每种情况发⽣的概率也考虑进去，那平均时间复杂度的计算过程就变成了这样：这个值就是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。

在大多数情况下，我们不需要区分最好、最坏、平均情况时间复杂度三种情况。

均摊时间复杂度

极限情况才会用到，可以不用理解。

数据结构与算法之美学习---复杂度分析