【算法】复杂度分析

第一章、如何分析代码的执行效率和资源消耗

        我们知道，数据结构和算法解决的是“快”和“省”的问题，也就是如何让代码运行得更快，一级如何让代码更节省计算机的存储空间。因此，执行效率是评价算法好坏的一个非常重要的指标。那么，如何衡量算法的执行效率尼？这里就要用到我们本节要讲的内容：时间复杂度分析和空间复杂度分析。

一、复杂度分析的意义

        我们把代码运行一遍，通过监控和统计手段，就能得到算法执行的时间和占用的内存大小，为什么还要做时间复杂度分析，空间复杂度分析呢？这种“纸上谈兵”似的分析方法比实实在在地运行一遍代码得到的数据更准确吗？

        实际上，这是两种不同的评估算法执行效率的方式。对于运行代码来统计复杂度的方法，很多有关数据结构和算法的图书还给它起了一个名字：事后统计法。这种统计方法看似可以给出非常精确的数值，但是却有非常大的局限性。

1、测试结果受测试环境的影响很大

        在测试环境中，硬件的不同得到的测试结果会有很大的差异。例如，我们用同样一段代码分别在安装了Intel Core i9处理器（CPU）和Intel Core i3处理器的计算机上运行，显然，代码在安装了Intel Core i9处理器的计算机上要比在安装了Intel Core i3处理器的计算机上的执行速度快得多。又如，在某台机器上，a代码执行的速度比b代码快，当我们换到另外一台配置不同的机器上时，可能会得到截然相反的运行结果。

2、测试结果受测试数据的影响很大

        我们会在后续章节详细讲解排序算法，这里用它进行举例说明。对同一种排序算法，待排序数据的有序度不一样，排序执行的时间会有很大的差别。在极端情况下，如果数据已经是有序的，那么有些排序算法不需要做任何操作，执行排序的时间就会非常短。除此之外，如果测试数据规模太小，那么测试结果可能无法真实地反应算法的性能。例如，对于小规模的数据排序，插入排序反而比快速排序快！

        因此，我们需要一种不依赖具体的测试环境和测试数据就可以粗略地估计算法执行效率的方法。这就是本节要介绍的时间复杂度分析和空间复杂度分析。

二、大O复杂度表示法

        如何在不运行代码的情况下，用“肉眼”分析代码后得到一段的执行时间尼？下面用一段非常简单的代码来举例，看一下如何估算代码的执行时间。求1~n的累加和的代码如下所示：

public static int cumulativeSum(int n){
        int result = 0;
        for (int i = 1; i <= n; i++){
            result += i;
        }
        return result;
}

        从在CPU上运行的角度来看，这段代码的每一条语句执行类似的操作：读数据--运算--写数据。尽管每一条语句对应的执行时间不一样，但是，这里只是粗略估计，我们可以假设每条语句执行的时间一样，为unit_time。在这个假设的基础上，这段代码的总执行时间是多少尼？

        执行第2，6行代码分别需要1个unit_time的执行时间；第3，4行代码循环运行了n遍，需要 2n x unit_time的执行时间。因此，这段代码的总执行时间为(2n + 2) x unit_time的执行时间。通过上面的举例分析，我们得到一个规律：一段代码的总的执行时间为T(n)（例子中的(2n + 2) x unit_time）与每一条语句的执行次数（累加数）（例子中的2n + 2）成正比。

        按照这个分析思路，我们再来看另一段代码，如下所示：

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

        依旧假设每条语句的执行时间为unit_time，那么这段代码的总的执行时间是多少尼？

        对于第2，3，4，11行代码，每行代码需要1个unit_time的执行时间。第5，6行代码循环执行了n遍，需要2n x unit_time的执行时间。第7，8行代码循环执行了n²遍，需要2n² x unit_time的执行时间。因此，整段代码总的执行时间为T(n) = (2n² + 2n + 4) x unit_time。尽管我们不知道unit_timede 具体值，而且，每一条语句执行时间unit_time可能都不尽相同，但是，通过这两段代码执行时间的推导过程，可以得到一个非常重要的规律：

一段代码的执行时间T(n)与每一条语句总的执行次数（累加数）成正比。

我们可以把这个规律总结成一个公式，如下所示：

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

        下面具体解释一下公式。其中，T(n)表示代码执行的总时间；n表示数据规模；f(n)表示每条语句执行次数的累加和，这个值与n有关，因此用f(n)这样一个表达式来表示；公式中的O这个符号，表示代码的执行时间T(n) 与 f(n)成正比。

        套用这个大O表示法，第一个例子中的T(n) = (2n + 2) x unit_time = O(2n + 2)，第二个例子中的T(n) =  (2n² + 2n + 4) x unit_time = O(2n² + 2n + 4)。实际上，大O时间复杂度并不具体表示代码真正的执行时间，而是表示代码执行时间随着数据规模增大的变化趋势，因此，也称为渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

        当n很大时，读者可以把它想象成10000,100000，公式中的低阶，常量，系数3部分并不控制增长趋势，因此可以忽略。我们只需要记录一个最大量级。如果用大O表示法表示上面的两段代码的时间复杂度，就可以记为：T(n) = O(n) 和 T(n) = O(n²)。        

补充知识：

在数学中，我们经常会听到关于“高阶”、“低阶”、“常量”和“系数”的术语。让我来解释一下：

1. 高阶（High-order）：在多项式或函数中，高阶项是指指数较高的项。例如，在多项式 ax^n+bx^(n−1)+cx^(n−2)+… +d 中，ax^n 就是高阶项，n 是高阶项的指数。通常来说，当 n 越大，该项的影响就越显著，因此被称为“高阶”。

2. 低阶（Low-order）：与高阶相对应，低阶项是指指数较低的项。在上面的多项式中，bx^(n−1) 和 cx^(n−2) 就是低阶项。这些项的影响相对较小，因为它们的指数较低。

3. 常量（Constant）：常量是没有包含任何变量的项，它们是数学表达式中的固定值。在多项式 ax^n+bx^(n−1)+cx^(n−2)+… +d 中，d 就是常量项。

4. 系数（Coefficient）：系数是与变量相乘的数字或参数。在多项式 ax^n+bx^(n−1)+cx^(n−2)+… +d 中，a、b 和 c 都是各自项的系数。系数决定了每个变量项的影响程度，它们可以是实数、复数或其他数学结构的成员。

在一个多项式中，通常高阶项对函数的整体形状和行为有着更显著的影响，而低阶项和常量则在更小的尺度上调整函数的细节。系数则决定了每个项的具体贡献。系数决定了变量的比例关系和对整个公式的影响程度。它们可以改变公式的斜率、曲线形状和整体大小。

三、时间复杂度分析方法

前面介绍了时间复杂度的由来和表示方法。现在，我们介绍一下如何分析一段代码的时间复杂度。下面讲解两个比较实用的法则：加法法则和乘法法则。

1、时间复杂度

时间复杂度是指执行算法所需要的计算工作量

        时间复杂度是用来衡量算法执行时间随着输入大小增加而增加的程度的一个度量。它表示算法的运行时间与输入数据的大小之间的关系。

        在计算时间复杂度时，通常考虑最坏情况下的运行时间，因为这能够给出算法的最差执行时间保证。时间复杂度用大O符号表示，通常写作O(f(n))，其中n表示输入大小，f(n)是一个函数，它描述了算法执行所需的时间与n的关系。

        例如，一个具有时间复杂度O(n)的算法表示，当输入大小增加n倍时，它的运行时间也将增加n倍。而一个具有时间复杂度O(n^2)的算法表示，当输入大小增加n倍时，它的运行时间将增加n的平方倍。

        时间复杂度的计算可以帮助我们选择合适的算法来解决特定问题，并预测算法在实际应用中的性能表现。通常来说，我们会选择具有较低时间复杂度的算法，尤其是当处理大量数据时。

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

        大O复杂度表示方法只表示一种变化趋势。我们通常会忽略公式中的常量，低阶和系数，只记录最大量级。因此，在分析一段代码的时间复杂度的时候，我们也只需要关注循环执行次数最多的那段代码。

        我们来看下面这样一段代码。读者可以先试着分析一下这段代码的时间复杂度，然后与作者分析的思路进行比较，看看思路是否一致。

public static int cal1(int n){
        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;
}

复杂度分析：

• 2   2 * 100
• 2   2 * n
• 3   2 * n   2 * n^2
• 1

2 * n^2 + 4 * n + 208

        上述这段代码分为4部分，分别是求sum_1，sum_2，sum_3，以及对这3个数求和。我们分别分析每一部分代码的时间复杂度，然后把它们放到一起，再取一个量级最大的作为整段代码的时间复杂度。

        求sum_1这部分代码的时间复杂度是多少尼？因为这部分代码循环执行了100次（p=100，一直不变，p是个常量），所以执行时间是常量。

        这里要再强调一下，即便这段代码循环执行10000次或100000次，只要是一个已知的数，与数据规模n无关，这也是常量级的执行时间。回到大O时间复杂度的概念，时间复杂度表示的是代码执行时间随数据规模（n）的增长趋势，因此，无论常量级的执行时间多长，它本身对增长趋势没有任何影响，在大O复杂度表示法中，我们可以将它（常量）忽略。

        求sum_2，sum_3，以及对这3个数求和这三部分代码的时间复杂度分别是多少尼？答案是O（n），O(n²)，常量。读者应该很容易就分析出来，就不在赘述了。

        综合这4部分代码的时间复杂度，我们取其中最大的量级，因此，整段代码的时间复杂度就为O(n²)。也就是说，总的时间复杂度等于量级最大的那部分代码的时间复杂度。这条法则就是加法法则，用公式表示出来，如下所示：

如果：

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) X T2(n) = O(f(n)）X  O(g(n)) = O(f(n) X g(n))

也就是说：假设T1(n) = O(n)，T2(n) = O(n²)，则T1(n) X T2(n) = O(n³)。落实到具体的代码上，我们可以把乘法法则看成嵌套循环。我们通过例子来解释一下，如下所示

public static void cal(int n){
        int ret = 0;
        int i = 1;
        for (; i <= n; i++){
            ret = ret + f(i);
        }
}

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

 

        我们单独观察上述代码中的cal()函数，在cal()函数的时间复杂度为T1 = O(n)，f()函数的时间复杂度为T2(n) = O(n)，则总的时间复杂度为T(n) = T1(n) X T2(n) = O(n X n) = O(n²)。

四、几种常见的时间复杂度量级

        虽然代码千差万别，但常见的时间复杂度量级并不多。简单总结一下，如图所示，这个涵盖了读者今后可以接触的绝大部分的时间复杂度量级。

计算数量级通常是对一个数的大小进行粗略估计，以确定它属于哪个数量级。这种估计可以通过以下步骤进行：

1. 将数写成科学计数法：将数写成形如 a×10^b的形式，其中 1≤a<10 是尾数，b 是指数。例如，1234 可以写成 1.234×10^3。

2. 确定尾数 a 的范围：确定尾数 a 的范围。通常来说，a 范围在 1 到 10 之间。

3. 确定指数 b 的值：指数 b 表示了数值在数量级上的大小。例如，10^3 表示数值在数量级上是千级别的。

4. 确定数量级：根据指数 b 的值来确定数量级。例如，b 为 3 表示数值在数量级上是千级别的。

        举例来说，假设有一个数值是 6.78×10^5。尾数 a 是 6.78，指数 b 是 5。因为 b 是 5，所以这个数值在数量级上是百万级别的。

        注意，计算数量级是一个近似值的过程，因此结果可能不是精确的，但通常足够用于粗略估计

        数量级是用来描述数值的大小或者范围的概念。在科学和工程领域中，我们经常需要处理非常大或非常小的数值，使用数量级可以更方便地表示这些数值。

        数量级通常以10为基数进行表示，通过指数形式来表示数值的大小。例如，一个数值的数量级为10^3，表示这个数值是1000的量级。同样地，一个数值的数量级为10^-3，表示这个数值是0.001的量级。

        数量级的概念可以帮助我们更好地理解和比较不同数值之间的大小关系。例如，如果两个数值的数量级相差很大，那么它们之间的差异也会非常显著。

在科学和工程中，常用的数量级包括：

• 巨大数量级：10^9、10^12、10^15等，用于表示亿、万亿、千万亿等非常大的数值。
• 中等数量级：10^0、10^1、10^2等，用于表示一般的数值范围。
• 微小数量级：10^-3、10^-6、10^-9等，用于表示千分之一、百万分之一、十亿分之一等非常小的数值。

        总之，数量级是一种用来描述数值大小或范围的概念，通过指数形式表示数值的量级。它在科学和工程领域中被广泛应用。

接下来，我们介绍几种常见的时间复杂度量级。 

 1、O(1)

        只要代码的执行时间不随数据规模n变化，代码就是常量级时间复杂度，统一记作O(1)。需要特别强调的是，O(1)是常量级时间复杂度的一种表示方法，并不是指就只执行了一行代码。例如：下面这段代码，尽管它包含了3行代码，但时间复杂度照样记为O(1)，而不是O(3)。

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

2、O(logn)，O(nlogn)

        对数阶时间复杂度非常常见，但是它是最难分析的时间复杂度之一。我们通过一个例子来解释一下，如下所示。

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

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

        从上述代码中可以看出，变量i从1开始取值，每循环一次就乘以2，当i值大于n时，循环结束，那么总共执行了多少次循环尼？实际上，变量i的取值就是一个等比数列。如果我们把它的取值序列写出来，就应该是下面这个样子。

        i 的取值序列：2º，2¹，2²，...，2ⁿ。i 初始值为1 （2º），当i （2ⁿ）> a时，循环终止。

        因此，只要求出 n 是多少时，我们就知道循环执行了多少次。对于在 2ⁿ = a 中求解n这个问题，直接给出答案：

以2为底，a 的对数。因此，这段代码的时间复杂度就是：

现在，我们把上面的代码稍微修改一下，如下所示，这段代码的时间复杂度是多少尼？

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

修改后的代码的时间复杂度为：

具体的分析我就不赘述了，读者可以参照上面讲的分析方法，自己试着分析一下。

        实际上，无论是以2或3为底，还是以10为底，我们可以把所有对数阶的时间复杂度统一记为O(logn)，这是为什么尼？

        根据对数之间的换底公式，log3n = log32 x log2n，因此O(log3n) = O(C x log2n)，其中C = log32是一个常量。基于前面的理论，在采用大O复杂度表示法的时候，我们可以忽略系数，即O(C x f(n)) = O(f(n))。因此，O(log2n)等于O(log3n)。因此，对于对数阶时间复杂度，我们忽略对数的“底”，统一表示为O(logn)。

        如果读者理解了前面讲的O(logn)，那么对于O(nlogn)就容易理解了。还记得上面提到的乘法法则吗？如果一段代码的时间复杂度是O(logn)，那么这段代码循环执行了n遍，时间复杂度就是O(nlogn)。O(nlogn)是一种常见的时间复杂度。例如，归并排序，快速排序的时间复杂度都是O(nlogn)。我们会在第3章详细分析排序算法。

3、O(m + n)，O(mn)

        现在，我们介绍一种比较特殊的情况：代码的时间复杂度由两个数据规模来决定。按照上面讲解的惯例，还是先看一段代码。

int cal(int m, int n){
    int sum_1 = 0;
    int i = 1;
    for(; i <= m; i++){
        sum_i = 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)。

五、空间复杂度分析方法

        上文详细介绍了大O复杂度表示法和时间复杂度分析方法，理解了这些内容，读者学习空间复杂度分析就变得非常简单了。

        前面我们讲到，时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。类比一下，空间复杂度的全称是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系。

        我们还是通过具体的例子来解释一下空间复杂度，代码如下所示：

public void reverse(int[] a, int n){
    int tmp[] = new int[n];
    for(int i = 0; i < n; i++){
        tmp[i] = a[n - i - 1];
    }
    for(int i = 0; i < n; i++){
        a[i] = tmp[i];
    }
}

        与时间复杂度分析类似，在第3行代码中，申请了一个空间来存储变量i，但是它是常量阶的，与数据规模n没有关系，也就是说，i 占用的存储空间并不会随着数据规模n变化，因此，在用大O复杂度表示法来表示空间复杂度的时候，可以将其省略。在第2行代码中，申请了一个大小为n的int类型数组，除此之外，剩下的代码没有占用更多的内存空间，因此，整段代码的空间复杂度就是O(n)。

        常见的空间复杂度有：O(1)，O(n)，O(n²)，O(logn) 和 O(nlogn)，其中，O(logn) 和 O(nlogn)这样的对数阶复杂度常见于递归代码。总体来说，空间复杂度分析比时间复杂度分析要简单很多。

1、空间复杂度

而空间复杂度是指执行这个算法所需要的内存空间。

空间复杂度是衡量算法空间利用率的度量标准，也就是算法在执行过程中所需要的存储空间大小。

在计算空间复杂度时，通常会考虑以下几个因素：

算法本身所需要的空间：例如程序中定义的变量、数组、对象等。

输入数据所占用的空间：例如在排序算法中，需要占用额外的数组空间来存储输入数据。 算法执行过程中所占用的空间：例如在递归算法中，每个递归调用都需要分配额外的栈空间。

空间复杂度通常用大O符号（O）表示，与时间复杂度类似。例如，如果一个算法的空间复杂度为O(n)，则它所需要的存储空间与输入数据的大小n成正比。

在实际应用中，除了考虑算法的时间复杂度之外，也需要考虑空间复杂度。对于内存有限的嵌入式系统或移动设备等场景，空间复杂度的控制非常重要，因为过高的空间复杂度会导致程序崩溃或无法运行。

六、内容小结

        复杂度也称为渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法的执行效率和内存消耗与数据规模之间的增长关系。复杂度越高阶的算法，执行效率越低，内存消耗越大。常见的复杂度并不多，从低阶到高阶：O(1)，O(logn)，O(n)，O(nlogn)，O(n²)，覆盖了几乎所有的数据结构和算法的复杂度。其中，O(logn)，O(n)，O(nlogn)，O(n²)这几个复杂度量级的增长趋势对比如图所示：

常用数学公式图像

 

        复杂度分析并不难，关键在于多练习。在后续章节中，作者会带领读者详细地分析每一种数据结构和算法的时间复杂度和空间复杂度。只要跟着作者的思路进行学习和练习，读者很快就能熟练掌握复杂度分析。对于简单的代码，读者一眼就能看出其复杂度，对于复杂的代码，稍微分析一下就能得出答案。 

七、思考题

有人说，我们的项目都会进行性能测试，如果再做代码的时间复杂度分析，空间复杂度分析，那么是不是多此一举尼？而且，每段代码都分析一下时间复杂度，空间复杂度，是不是浪费时间尼？读者怎么看待这个问题尼？

        性能测试和时间复杂度、空间复杂度分析是两个不同的概念，它们各自有着不同的目的和应用场景。

        性能测试是用来评估系统或者软件在特定条件下的性能表现，包括响应时间、吞吐量、并发性等指标。通过性能测试可以发现系统的瓶颈和性能问题，从而进行优化和改进。

        而时间复杂度和空间复杂度分析是用来评估算法的效率和资源消耗的。它们是在设计和实现阶段进行的，通过对算法的时间和空间需求进行分析，可以帮助开发人员选择更优的算法，提高代码的执行效率和资源利用率。

        虽然性能测试可以检测系统在实际运行环境下的性能表现，但它并不能完全代替时间复杂度和空间复杂度分析。因为性能测试是在具体数据和环境条件下进行的，而时间复杂度和空间复杂度分析是对算法本身进行评估，不受具体数据和环境的影响。通过时间复杂度和空间复杂度分析，可以更好地理解算法的效率和资源消耗，并在设计阶段就选择合适的算法。

        对于每段代码都进行时间复杂度和空间复杂度分析的问题，确实会增加一定的工作量。但这并不是浪费时间，而是为了保证代码的质量和性能。通过分析代码的时间复杂度和空间复杂度，可以发现潜在的性能问题和资源浪费，及时进行优化和改进。这样可以提高代码的执行效率，减少资源消耗，提升系统的整体性能。

        读者对于这个问题的看法可能因人而异。有些读者可能认为时间复杂度和空间复杂度分析是必要的，可以帮助开发人员选择更优的算法和优化代码。而有些读者可能认为这样做会增加开发时间和工作量，不值得花费过多精力在分析上。不同的观点都有一定的道理，具体应该根据项目需求、时间和资源等因素来综合考虑。

第二章、详解最好，最坏，平均，均摊这4种时间复杂度

        在上一章中，我们讲了复杂度的大O表示法和分析方法，还举了一些常见复杂度分析的例子，如O(1)，O(logn)，O(n)，O(nlogn)，O(n²)复杂度分析。

        在本章中，我们继续进行时间复杂度分析，介绍4个更加细分的复杂度概念：最好情况时间复杂度（best case time complexity），最坏情况时间复杂度（worst case time complexity），平均情况时间复杂度（average case time complexity）和均摊时间复杂度（amortized time complexity）

一、最好时间复杂度和最坏时间复杂度

        我们在上一章举的分析复杂度的例子都很简单，本章我们来看一下稍微复杂的例子，如下所示。读者可以用上一章中介绍的分析方法，自己先试着分析一下这段代码的时间复杂度。

//n表示数组array的长度
int find(int[] array, int n, int x){
    int i = 0;
    int pos = -1;
    for(; i < n; i++){
        if(ayyay[i] == x) pos = i;
    }
    return pos;
}

        上述代码要实现的功能：在一个无序的数组（array）中，查找变量x出现的位置。如果没有找到，就返回-1。按照上一章介绍的分析方法，这段代码的复杂度是O(n)，其中，n代表数组的长度。

        实际上，在数组中查找一个数据时，我们并不一定要把整个数组遍历一遍，有可能中途找到后就提前结束循环了。按照这个思路，我们对上面的代码进行优化，优化后的代码如下所示：

//n表示数组array的长度
int find(int[] array, int n, int x){
    int i = 0;
    int pos = -1;
    for(; i < n; i++){
        if(ayyay[i] == x){
            pos = i;
            break;
        }
    }
    return pos;
}

        这个时候，问题就来了。优化之后的代码的时间复杂度还是O(n)吗？显然，上一章介绍的分析方法解决不了这个问题。

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

        为了表示代码在不同情况下的不同时间复杂度，我们引入3个概念：最好情况时间复杂度，最坏情况时间复杂度和平均时间复杂度。为了方便表述，在平时的开发中，我们往往把他们简称为：最好时间复杂度，最坏时间复杂度和平均时间复杂度。

顾名思义，最坏情况时间复杂度就是：在最好的情况下，执行这段代码的时间复杂度。

        就想我们刚刚讲到的，在最好的情况下，要查找的变量x正好是数组的第一个元素，这种情况下对应的时间复杂度就是最好情况时间复杂度O(1)。

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

        就像刚举的那个例子，如果数组中没有要查找的变量x，就需要把整个数组遍历一遍，这种情况下对应的时间复杂度就是最坏情况时间复杂度O(n)。

二、平均时间复杂度

        最好时间复杂度和最坏时间复杂度对应的都是极端情况下的时间复杂度，发生的概率其实并不大。为了更好地表示平均情况下的复杂度，我们需要引入平均时间复杂度这个概念。

平均时间复杂度指的是代码被重复执行无数次，对应的时间复杂度的平均值。

平均情况时间复杂度该怎么分析尼？我们还是借助刚才那个例子来解释：

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

        前面讲到，在用大O表示法表示时间复杂度的时候，我们可以省略系数，低阶，和常量，因此，上式简化之后，得到的平均情况时间复杂度就是O(n)。

        尽管平均时间复杂度是O(n)这个结论是正确的，但计算过程稍微有点问题。问题在于：刚讲的这n+1中情况出现的概率并不相同。接下来，我们具体分析一下。这里要用到一些概率论的知识，不过非常简单。

        我们知道，要查找的变量x，要么在数组里，要么不在数组里。这两种情况出现的概率都是1/2。另外，要查找的数据出现在 0~n-1 这n个位置的概率也是一样的，为 1/n。因此，根据概率乘法法则，要查找的数据出现在 0~n-1 中任意位置的概率是 1/(2n)。

        前面的推导过程存在的最大问题是没有将各种情况发生的概率考虑进去。如果我们把每种情况发生的概率也考虑进去，那么平均时间复杂度的计算过程就变成了下式：

        这个值就是概率论中的加权平均值，也称为期望值。因此，平均时间复杂度更准确的描述应该为加权平均时间复杂度或者期望时间复杂度。

        加权平均值是一种计算平均值的方法，它考虑了每个数据点的权重。在计算加权平均值时，每个数据点的值乘以其对应的权重，然后将所有乘积相加，最后再除以所有权重的总和。

具体计算公式如下： 加权平均值 = (数据点1 × 权重1 + 数据点2 × 权重2 + … + 数据点n × 权重n) / (权重1 + 权重2 + … + 权重n)

        举个例子，假设有三个数据点和对应的权重： 数据点1 = 10，权重1 = 2 数据点2 = 15，权重2 = 3 数据点3 = 20，权重3 = 1

        那么加权平均值的计算如下： 加权平均值 = (10 × 2 + 15 × 3 + 20 × 1) / (2 + 3 + 1) = 15

所以，这个例子中的加权平均值为15。

        在引入概率之后，加权平均值为 (3n + 1)/4 。用大O复杂度表示法来表示，去掉系数和常量，任然是O(n)，与前面给出的结果相同。

        读者可能会认为，平均情况时间复杂度分析真复杂，还设计概率论的知识。实际上，在大多数情况下，我们并不需要区分最好时间复杂度，最坏时间复杂度和平均时间复杂度这3种情况。对于上一章中的那些例子，在任何情况下，性能表现都一样，因此我们使用一种复杂度来表示就足够了。只有当同一段代码在不同情况下性能表现不同，并且时间复杂度有量级上的差别时，我们才会使用这3种不同的复杂度来表示。

三、均摊时间复杂度

        下面我们介绍平均时间复杂度的一个特殊情况：均摊时间复杂度。同事，我们会介绍均摊时间复杂度对应的分析方法：摊还分析法（也称为平摊分析法）。我们还是通过一个具体的例子来讲解，代码如下所示：

//array和count是类成员变量或者全局变量
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 += array[i];
        }
        System.out.println(sum);
        count = 0;
    }
    array[count] = val;
    count++;
}

        上面这段代码实现了向数组中插入数据的功能。如果数组中有未占用空间，就直接将数组插入数组。当数组满了之后（count == array.length），用for循环遍历数组并求和，同时清空数组（count表示数组中元素个数，count = 0就表示清空了数组），然后将新数据插入。

        那么insert() 函数的时间复杂度是多少尼？我们先用刚才介绍的3种时间复杂度的分析方法来分析一下。

        在最好的情况下，数组中有未占用空间，此时只需要将数据插入到数组下标为count的位置，因此，最好时间复杂度为O(1)。在最坏的情况下，数组中没有未占用空间，此时需要先进行一次数组的遍历求和，然后将数据插入，因此，最坏时间复杂度为O(n)。

        那么平均情况时间复杂度是多少尼？这里稍微强调一下，insert()函数的平均时间复杂度指的是多次调用这个函数对应的时间复杂度的平均值。对于平均时间复杂度，我们先用前面提到的概率论的分析方法来分析。

        假设数组的长度是n。当数组中有未占用空间时，插入数据的时间复杂度是O(1)。根据插入位置的不同（下标为0~n-1的位置），它又分为n种情况。除此之外，在数组没有未占用空间时，插入一个数据需要遍历数组，对应的时间复杂度为O(n)。这 n + 1 种情况发生的概率是一样的，都是 1/(n+1)。因此，根据加权平均值的计算方法，平均时间复杂度的计算公式如下式：

        不过，对于insert()函数的平均时间复杂度分析，其实没有这么复杂，并不需要引入概率论的知识。这是为什么尼？我们对比一下insert()函数和前面的find()函数，读者就会发现这两者有很大的差别。

        首先，find()函数在极端情况下，复杂度才为O(1)。而insert()函数在大部分情况下，时间复杂度为O(1)，只有在个别情况下，复杂度才比较高，为O(n)。这是insert()函数区别于find()函数的第一个地方。

        我们再来看这两个函数第二个不同的地方。对于insert()函数，O(1)时间复杂度的插入和O(n)时间复杂度的插入出现的频率是非常有规律的，有一定的前后时序关系，一般是在一个O(n)时间复杂度的插入之后，紧跟着 n 个O(1)时间复杂度的插入操作，不断循环。

        针对这样一种特殊场景的平均时间复杂度分析，我们可以不用概率论的分析方法，而是引入一种个更加简单的分析方法：摊还分析法。对于通过摊还分析法得到的时间复杂度，我们给它起了一个更加特殊的名字----均摊时间复杂度。

        那么究竟如何使用摊还分析法来分析算法的均摊时间复杂度尼？

        我们还是继续看上面给出的那个例子。每一次O(n)时间复杂度的插入都会跟着 n 次O(1)时间复杂度的插入操作，因此，如果我们把耗时多的那次操作的耗时均摊到接下来的n次耗时少的操作上，那么均摊下来，这一组连续插入操作的均摊时间复杂度就是O(1)。

        均摊时间复杂度和摊还分析法的应用场景比较特殊，因此，他们并不是很常用。为了方便读者理解，记忆，这里简单总结一下他们的应用场景。

        对一个数据结构进行一组连续操作，在大部分情况下，时间复杂度很低，只有个别情况下，时间复杂度比较高，而且，这些操作之间存在前后连贯的时序关系，这个时候，我们就可以将这一组操作放在一起分析，观察是否能将较高时间复杂度的那次操作的耗时均摊到其他较低时间复杂度的操作上。还有，在能够应用均摊时间复杂度分析的场景中，一般均摊时间复杂度就等于最好时间复杂度。

四、内容小结

        本节介绍了几个复杂度分析相关的概念，他们分别是：最好时间复杂度，最坏时间复杂度，平均时间复杂度和均摊时间复杂度。之所以引入这几个复杂度概念，是因为同一段代码在不同输入的情况下性能表现有可能不同，复杂度量级有可能不一样。

        在引入这几个概念之后，我们可以更加全面地表示一段代码的执行效率。而且，这几个概念理解起来并不难。最好时间复杂度和最坏时间复杂度分析起来比较简单，但平均时间复杂度和均摊时间复杂度分析起来相对要复杂一些。如果读者觉得理解得还不是很深入，那么也不必担心，因为在后续具体的数据结构和算法学习中，可以继续对相关内容进行实践。

五、思考题

分析一下下面这段代码中add()函数的时间复杂度

//类成员变量或全局变量：数组为array，长度为n，下标为i
int[] array = new int[10]; //初始大小为10
int n = 10;
int i = 0;
void add(int element){
    if(i >= n){ //数组空间不够了
        //重新申请一个n的2倍大小的数组空间
        int[] newArray = new int[2 * n];
        //把原来array数组中的数据依次复制到newArray
        for(int j = 0; i < n; i++){
            newArray[j] = array[j];
        }
        //newArray复制给array，array现在是n的2倍大小
        array = newArray;
        n = 2 * n;
    }
    array[i] = element;
    i++;
}

        这里所说的add()函数的时间复杂度指的是多次调用add()函数时，add()函数执行效率的表现情况。尽管n初始化为10，但n的大小一直在变化，因此，我们不能认为算法是常量级的时间复杂度。

        当 i < n时，即 i = 0,1,2...,n-1，代码不执行for循环，因此，这n次调用add()函数的时间复杂度都是O(1)；当i = n时，for循环进行数组的复制，因此，这次调用add()函数的时间复杂度是O(n)。由此可知：

• 最好情况时间复杂度是O(1)
• 最坏情况时间复杂度是O(n)
• 平均或均摊情况时间复杂度为O(1)

        其中，平均或均摊时间复杂度适合采用均摊时间复杂度分析法来分析。我们把时间复杂度为O(n)的那次操作的耗时均摊到其他n次时间复杂度为O(1）的操作上，均摊下来的时间复杂度就是O(1)。