数据结构与算法|第二章：复杂度分析-续

数据结构与算法|第二章：复杂度分析-续

前言

本章会讨论四个复杂度分析的概念

• 最好情况时间复杂度（best case time complexity）
• 最坏情况时间复杂度（worst case time complexity）
• 平均情况时间复杂度（average case time complexity）
• 均摊时间复杂度（amortized time complexity）

1.项目环境

• jdk 1.8
• github 地址：https://github.com/huajiexiewenfeng/data-structure-algorithm
  • 本章模块：chapter02

2.示例分析

我们先看一段简单的代码：找到数组中元素为 x 的下标位置

    public static int find(int[] array,int n,int x) {
        int pos = -1;
        for (int i = 0; i < n; i++) {
            if(array[i]==x){
                pos = i;
            }
        }
        return pos;
    }

根据我们上一章的内容可以分析出来这段代码的时间复杂度为 O(n)，但是我们每次找出对应的元素，并不需要将整个数组遍历一遍，代码可以进行以下优化

    public static int find2(int[] array, int n, int x) {
        int pos = -1;
        for (int i = 0; i < n; i++) {
            if (array[i] == x) {
                pos = i;
                break;
            }
        }
        return pos;
    }

与之前的不同点在于要查找的变量 x 可能在 array 数组的任意位置，导致这段代码的时间复杂度和之前的情况有所不同

• 如果 x 元素在第一个，那么只需要循环一次就可以找到，那么代码的时间复杂度就是 O(1)
• 如果 x 元素在数组的最后一个，那么时间复杂度又变回成了 O(n)

所以在不同的情况下，代码的时间复杂度是不一样的，因此我们需要引入三个概念来进行分析

2.1 最好情况时间复杂度（best case time complexity）

上面的例子中，最好情况时间复杂度就是 array 数组的第一个元素就是 x，那么时间复杂度就是 O(1)。

2.2 最坏情况时间复杂度（worst case time complexity）

反之最坏的情况就是 array 数组的第最后一个元素是 x 或者没有 x 元素，那么时间复杂度就是 O(n)。

2.3 平均情况时间复杂度（average case time complexity）

最好和最坏的情况其实概率很低，所以我们需要引入另一个概念，平均情况时间复杂度。

前提： 假设查找的元素一定在数组中（为了理解方便）

在长度为 n 的数组中，我们查找每个元素的概率是 1/n。

x 查找 1 次被找到的概率 = 1*1/n

x 查找 2 次被找到的概率 = 2*1/n

…

将所有的概率加在一起就可以得到平均情况时间复杂度计算如下

$1\ast 1/n+2\ast 1/n+3\ast 1/n+...+n\ast 1/n=(n+1)/2$

去掉系列、常量的影响，我们发现平均情况时间复杂度还是为 O(n)；和上面的两种复杂度相比，稍微有点复杂，虽然已经屏蔽了一些因素。

在大部分情况下，我们并不会分析这三种复杂度，只有同一块代码在不同的情况下，时间复杂度有量级的差距，我们才会使用这三种复杂度表示法来区分。

2.4 均摊时间复杂度（amortized time complexity）

实现功能如下：

• 向 array 数组中循环插入 val 值
• 如果 count == array.length 长度达到数组的最大长度
• 那么将现数组中的所有元素之和添加到数组的第一个元素中
• 再接着添加元素

    static int count = 0;

    public static void insert(int[] array, 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;
    }

调用代码

    public static void main(String[] args) {
        // 均摊时间复杂度
       int[] array = new int[5];

        for (int i = 0; i < 6; i++) {
            insert(array, i);
        }

        printlnArray(array);

    }

执行结果：

10,5,2,3,4

上述代码只是为了说明 均摊时间复杂度，不需要纠结实现细节。

我们先分析下时间复杂度

• 最好时间复杂度 O(1)，当 count 值 < 数组长度时
• 最坏时间复杂度 O(n)，当 count 值 = 数组长度时，需要遍历数组
• 平均时间复杂度 O(1)，计算如下：

假设数组长度为 n 那么平均时间复杂度计算公式为
$$1\ast 1/n+1+1\ast 1/n+1+...+1\ast 1/n+1+n\ast 1/n+1=O(1)$$
insert() 和上面的 find() 最大区别在于，在 find 中大部分情况下时间复杂度为 O(n)，极少数情况下才为O(1)，而 insert() 正好相反。

在这种特殊的场景下需要引入一种新的分析方法：均摊时间复杂度

在 insert 这个例子中，每次触发 count == array.length 这个条件时，都会执行 n-1 次的时间复杂度为 O(1) 插入操作，才会执行一次复杂度为 O(n) 插入，如果把耗时最多的这次操作时间均摊到这 n-1 次中，这个连续 n 次的插入操作的时间复杂度还是 O(1)，这种时间均摊的统计分析方法就是 均摊时间复杂度。

3.小结

本章讨论这四个复杂度概念，是因为同一段代码，在不同输入的情况下，复杂度量级有可能是不一样的。在引入这几个概念之后，我们可以更加全面地表示一段代码的执行效率。

平均情况时间复杂度 和 均摊时间复杂度 看起来比较类似，所以有点难以理解和区分，我们不用花太多时间去区分他们，都是在一些比较特殊的场景分析采用用到，一般 均摊时间复杂度 就等于最好情况时间复杂度。

4.参考

• 极客时间 -《数据结构与算法之美》王争