《数据结构与算法之美》02——复杂度分析

大O复杂度表示法

大O复杂度表示法，表示代码执行时间随数据规模增长的变化趋势，也叫作渐进时间复杂度，简称时间复杂度。

时间复杂度分析

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

T(n)=O(2+n+1)=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. 乘法法则：嵌套代码的复杂度等于嵌套内外代码的复杂度的乘积

如果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))

常见时间复杂度实例分析

1. O(1)

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

2. O(logn)、O(nlogn)

非常常见的算法时间复杂度，比如归并排序、快速排序的时间复杂度是O(nlogn)

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

代码复杂度由两个数据的规模决定。

空间复杂度分析

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

常见的空间复杂度有O(1)、O(n)、O(n2)

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

// 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的位置 ，时间复杂度是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;
}

最好情况时间复杂度是第一个元素刚好是要查找的变量x，这时候的时间复杂度是O(1)，如果数组里不存在变量x，那么时间复杂度是O(n)。

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

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

平均情况时间复杂度

按上面的例子，把所有情况（有n+1种）：在数组的0~n-1位置中和不在数组中，把每种情况查找要遍历的元素个数累加起来，再除以n+1，就是平均遍历的元素个数的平均值：

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

实际上还要考虑每种情况的出现的概率，比如每种情况出现的概率都是1/2，那么平均时间复杂度的推导公式：

引入概率之后，前面那段代码的加权平均值为(3n+1)/4。用大O表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是O(n)。

均摊时间复杂度

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

这段代码实现了一个往数组中插入数据的功能。当数组满了，就把数组里的求和，并清空数组，然后将求和放在数组的第一位。

最好情况时间复杂度：O(1)

最坏情况时间复杂度：O(n)

平均情况时间复杂度：O(1)。假设数组元素个数从0~n的概率一样，即1/(n+1)，那平均情况时间复杂度公式如下：

 

均摊时间复杂度：

看上面的例子（插入数据），每一次O(n)的插入操作，都会跟着n-1次O(1)的插入操作，把耗时多的那次操作均摊到接下来的n-1次耗时少的操作上，均摊下来的均摊时间复杂度是O(1)。

均摊时间复杂度是一种特殊的平均时间复杂度。

课后思考：

1、有人说，我们项目之前都会进行性能测试，再做代码的时间复杂度、空间复杂度分析，是不是多此一举呢？而且，每段代码都分析一下时间复杂度、空间复杂度，是不是很浪费时间呢？你怎么看待这个问题呢？

相对于做性能测试，时间复杂度、空间复杂度分析更加便捷、不需要额外的资源。在代码层面就已经做出判断，时间复杂度和空间复杂度不达标，重写代码即可。

而且性能测试是受测试环境影响，配置不一样，得出的结果不一样。

2、用今天学习的知识，来分析一下，下面这个add()函数的时间复杂度。

// 全局变量，大小为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;
}

最好时间复杂度：O(1)

数组空间不满，直接插入。

最坏时间复杂度：O(n)

数组空间满了，复制数组。

平均时间复杂度：O(1)

假设数组元素个数（0~n）的概率相同（1/n+1），那么计算公式为：

1/(n+1)+1/(n+1)+.......+n/(n+1)=2n/(n+1)=O(1)

均摊时间复杂度：O(1)

每次的复制数组操作（O(n)）都有n次的直接插入的操作（O(1)），均摊后是O(1)