1 概述

时间复杂度是衡量一个算法执行效率的重要指标，它描述了算法在输入规模增长时，所需执行时间的增长趋势。时间复杂度通常用大O记号表示，比如O(1)、O(n)、O(n²)、O(log n)等。以下是一些常见的时间复杂度及其含义：

1. O(1) - 常数时间复杂度

   • 这种算法在输入规模增大时，执行时间保持不变，不受输入规模影响。
   • 例如：数组访问、哈希表查找。

2. O(log n) - 对数时间复杂度

   • 这种算法的执行时间随着输入规模的增大而对数级增长，常见于二分查找等。
   • 例如：二分查找、平衡二叉树查找。

3. O(n) - 线性时间复杂度

   • 这种算法的执行时间与输入规模成正比，即输入规模翻倍，执行时间也翻倍。
   • 例如：线性查找、遍历数组。

4. O(n log n) - 线性对数时间复杂度

   • 这种算法的执行时间是输入规模的线性乘以对数级增长，常见于高效排序算法如快速排序、归并排序等。
   • 例如：快速排序、归并排序。

5. O(n²) - 平方时间复杂度

   • 这种算法的执行时间随着输入规模的平方级增长，常见于简单的排序算法如冒泡排序、选择排序等。
   • 例如：冒泡排序、选择排序。

6. O(2^n) - 指数时间复杂度

   • 这种算法的执行时间随着输入规模的指数级增长，通常出现在解决复杂的递归问题中。
   • 例如：斐波那契数列递归解法、汉诺塔问题。

7. O(n!) - 阶乘时间复杂度

   • 这种算法的执行时间随着输入规模的阶乘级增长，通常用于解决排列和组合问题。
   • 例如：旅行商问题的暴力解法。

2 时间复杂度的详细分析

2.1 常数时间复杂度（O(1））

在这种情况下，算法的执行时间不会随着输入规模的变化而变化。无论输入的规模多大，算法都只执行一个固定数量的操作。例如，访问数组中的某个元素，或者执行一个固定的算术运算。

2.2 对数时间复杂度（O(log n)）

这种复杂度通常出现在需要“二分”处理问题的算法中。常见的例子是二分查找。在每一步中，算法将输入数据分成两半，只处理其中的一半，因此执行时间随着输入规模的对数级增长。

2.3 线性时间复杂度（O(n)）

在这种情况下，算法的执行时间与输入规模成正比。每一个输入元素都会被处理一次。常见的例子包括简单的循环遍历数组、线性查找等。

2.4 线性对数时间复杂度（O(n log n)）

这种复杂度通常出现在一些高效的排序算法中，如快速排序和归并排序。算法将输入数据分成较小的部分（通常是对数级），然后分别处理这些部分。

2.5 平方时间复杂度（O(n²)）

这种复杂度通常出现在需要嵌套循环处理问题的算法中。每一个输入元素都会与每一个其他元素进行比较和处理。常见的例子包括冒泡排序、选择排序和插入排序。

2.6 指数时间复杂度（O(2^n)）

这种复杂度通常出现在一些递归算法中，每一步递归都会生成多个子问题。常见的例子包括计算斐波那契数列的递归方法、汉诺塔问题等。

2.7 阶乘时间复杂度（O(n!)）

这种复杂度通常出现在需要处理所有排列和组合问题的算法中。例如，旅行商问题的暴力解法就是一个阶乘时间复杂度的例子。

3 用户体验中的时间复杂度 🔥

#用户体验 #响应时间 #刹那 #须臾

根据《摩诃僧祗律》记载：一刹那为一念，二十念为一瞬，二十瞬为一弹指，二十弹指为一罗预，二十罗预为一须臾，一日一夜有三十须臾。可知:
1 须臾 = 24 小时 / 30 = 0.8 小时 = 48 分钟
1 罗预 = 1 须臾 / 20 = 48 分钟 / 20 = 2.4 分钟 = 2 分 24 秒
1 弹指 = 1 罗预 / 20 = 2.4 分钟 / 20 = 0.12 分钟 = 7.2 秒
1 瞬 = 1 弹指 / 20 = 7.2 秒 / 20 = 0.36 秒 = 360 毫秒
1 刹那 = 1 念 = 1 瞬 / 20 = 360 毫秒 / 20 = 18 毫秒

在实际的应用开发和用户体验中，响应时间对用户体验至关重要。以下是一些常见的响应时间要求和对应的描述：

• 刹那（Moment）：刹那可以认为是几十毫秒的响应时间。在理想状态下，页内操作应在刹那间解决，例如点击按钮、切换标签等，确保用户感受到即时的响应。

• 瞬间（Instantaneous）：瞬间的响应时间在几百毫秒以内。页面跳转应在瞬间解决，用户感觉不到延迟。

• 弹指（Blink of an Eye）：弹指级别的响应时间在几秒到十秒之间。对于复杂的操作，如上传大文件或处理复杂计算，响应时间较长时需要提供进度提示，告知用户操作正在进行中，并允许用户随时中止或取消。

4 计算时间复杂度的方法

为了理解和计算算法的时间复杂度，可以将其类比为一次探险，寻找算法的时间复杂度这个“宝藏”。以下是具体步骤：

1. 分析代码：观察代码中的每一步操作，找到它们之间的关系，以及它们执行的频率。

2. 分析循环：使用指南针（分析循环）判断方向，计算每一步操作的次数。

3. 处理递归：注意递归调用的频率，计算递归的深度和每次递归的操作次数。

4. 计算总时间：将所有操作次数加总，得到整个算法的时间复杂度。

5. 简化结果：将复杂度表达式简化，保留最高次项，忽略常数项和低次项，得到最终的时间复杂度。

通过这些步骤，我们可以准确地计算出算法的时间复杂度，从而更好地评估和优化算法的性能。

5 实际例子算法题

让我们通过一个实际例子来演示如何计算算法的时间复杂度。

5.1 二分查找算法

int binarySearch(int arr[], int left, int right, int x) {
    while (left <= right) {
        int mid = left + (right - left) / 2;

        // 检查x是否在中间位置
        if (arr[mid] == x) 
            return mid;

        // 如果x更大，忽略左半部分
        if (arr[mid] < x) 
            left = mid + 1;

        // 如果x更小，忽略右半部分
        else
            right = mid - 1;
    }
    // 元素不存在于数组中
    return -1;
}

步骤 1：分析代码

• 初始化中间位置 mid = left + (right - left) / 2
• 比较 arr[mid] 和 x
• 更新 left 或 right 以缩小搜索范围

步骤 2：分析循环

• while循环条件为 left <= right，在每次迭代中，搜索范围减半。

步骤 3：处理递归

二分查找算法是一个迭代过程，没有递归调用。

步骤 4：计算总时间

在每次迭代中，搜索范围减半，这意味着我们最多会执行 log₂n 次迭代，其中 n 是数组的长度。

步骤 5：简化结果

忽略常数项和低次项，我们得到时间复杂度为 O(log n)。

5.2 另一个例子：冒泡排序

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j] 和 arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

步骤 1：分析代码

• 两个嵌套的for循环
• 内循环中，每次迭代比较并交换相邻的元素

步骤 2：分析循环

• 外循环执行 n-1 次
• 内循环执行 n-i-1 次，其中 i 是外循环的当前迭代次数

步骤 3：处理递归

冒泡排序是一个迭代过程，没有递归调用。

步骤 4：计算总时间

总的执行次数为：∑_i=0^n-1​(n−i−1)=n(n−1)/2

步骤 5：简化结果

忽略常数项和低次项，我们得到时间复杂度为 O(n²)。

References