时间复杂度和空间复杂度

最新推荐文章于 2024-12-08 19:19:18 发布

小李学软件

最新推荐文章于 2024-12-08 19:19:18 发布

阅读量1k

点赞数 12

CC 4.0 BY-SA版权

分类专栏：算法文章标签：算法 leetcode

本文链接：https://blog.youkuaiyun.com/lzDevastator/article/details/142959197

算法专栏收录该内容

12 篇文章

订阅专栏

时间复杂度

时间复杂度是用来描述算法执行所需时间与输入规模之间关系的度量方式。它衡量的是算法在最坏情况下需要多少基本操作（如比较、赋值等）来完成任务。

常用的时间复杂度表示法是大 O 记号（Big O notation），它描述了当输入规模趋近于无穷大时，算法运行时间增长的趋势。

常见的时间复杂度分类：

O(1)：常数时间复杂度，算法的执行时间不随输入规模的变化而变化。
O(log n)：对数时间复杂度，算法的执行时间随输入规模的对数增长。
O(n)：线性时间复杂度，算法的执行时间与输入规模成正比。
O(n log n)：线性对数时间复杂度，常见于高效的排序算法，如快速排序、归并排序。
O(n^2)：平方时间复杂度，嵌套循环的算法通常具有此复杂度。
O(2^n)：指数时间复杂度，算法的执行时间随输入规模的指数增长。
O(n!)：阶乘时间复杂度，极高的时间复杂度，通常在解决排列组合问题时出现。

举例：

线性时间复杂度 O(n)：

function findMax(nums: number[]): number {
    let max = nums[0];
    for (let i = 1; i < nums.length; i++) {
        if (nums[i] > max) {
            max = nums[i];
        }
    }
    return max;
}

在这个函数中，我们需要遍历整个数组一次，所以时间复杂度是 O(n)。

平方时间复杂度 O(n^2)：

function bubbleSort(nums: number[]): number[] {
    for (let i = 0; i < nums.length; i++) {
        for (let j = 0; j < nums.length - i - 1; j++) {
            if (nums[j] > nums[j + 1]) {
                [nums[j], nums[j + 1]] = [nums[j + 1], nums[j]];
            }
        }
    }
    return nums;
}

在冒泡排序中，有两个嵌套的循环，每个循环的迭代次数与输入规模 n 成正比，所以时间复杂度是 O(n^2)。

空间复杂度

空间复杂度是指算法在执行过程中临时占用存储空间大小与输入规模之间的关系。它衡量的是算法在运行过程中需要多少额外的内存空间。

空间复杂度也使用大 O 记号来表示，常见的空间复杂度有：

O(1)：常数空间复杂度，算法所需的额外空间不随输入规模的变化而变化。
O(n)：线性空间复杂度，算法所需的额外空间与输入规模成正比。
O(n^2)：平方空间复杂度，所需的额外空间与输入规模的平方成正比。

举例：

常数空间复杂度 O(1)：

function swap(a: number[], i: number, j: number): void {
    const temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

这个函数只使用了有限的额外变量（temp），不随输入规模变化，空间复杂度是 O(1)。

线性空间复杂度 O(n)：

function copyArray(nums: number[]): number[] {
    const newArray = [];
    for (let i = 0; i < nums.length; i++) {
        newArray.push(nums[i]);
    }
    return newArray;
}

这里，我们创建了一个新的数组 newArray，其大小与输入数组 nums 的大小相同，所以空间复杂度是 O(n)。

为什么时间和空间复杂度重要？

性能预测：通过时间复杂度，可以预测算法在处理大规模数据时的性能表现。
资源优化：了解空间复杂度可以帮助我们设计占用更少内存的算法，尤其在资源受限的环境中。
算法比较：时间和空间复杂度是衡量不同算法优劣的重要标准，有助于选择最适合的算法解决问题。

时间复杂度的形象理解

例子：寻找宝藏

**场景描述：**想象你在一个长度为 n 的直线走廊上，地上有很多箱子，只有一个箱子里有宝藏。你的任务是找到这个宝藏。

线性时间复杂度 O(n)

动画场景：
1. **开始位置：**你站在走廊的起点。
2. **一步一步检查：**你从第一个箱子开始，逐个打开每个箱子，直到找到宝藏。
  - **第 1 个箱子：**空的。
  - **第 2 个箱子：**空的。
  - …
  - **第 n 个箱子：**找到宝藏！
3. **过程可视化：**随着你一个接一个地检查箱子，所需的时间与箱子数量成正比。
结论：这就是O(n) 的时间复杂度，意味着时间随着输入规模（箱子数量）线性增长。

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

**前提条件：**箱子按某种规则排序，比如按编号从小到大排列。
动画场景：
1. **开始位置：**你站在走廊的中间位置。
2. 每次排除一半：
  - **第一步：**查看中间的箱子，如果宝藏不在这里，根据宝藏可能的位置，选择左边或右边的一半继续。
  - **第二步：**在选择的一半中，再次找到中间位置，重复上述步骤。
  - …
3. **过程可视化：**每次行动都将剩余的搜索范围减半。
结论：这就是O(log n) 的时间复杂度，意味着时间随着输入规模的对数增长。

空间复杂度的形象理解

例子：搬运水果

**场景描述：**你有一堆水果需要搬运到另一个地方。

常数空间复杂度 O(1)

动画场景：
1. **工具：**你只有一个篮子。
2. **搬运过程：**每次用同一个篮子装水果，来回多次，直到搬完所有水果。
结论：不管有多少水果，你使用的篮子数量始终是一个，空间不随输入规模变化。这就是O(1) 的空间复杂度。

线性空间复杂度 O(n)

动画场景：
1. **工具：**为了提高效率，你准备了多个篮子，每个篮子装一个水果。
2. **搬运过程：**一次性搬运所有的篮子，篮子数量与水果数量相同。
结论：所需的空间（篮子数量）随着水果数量线性增长。这就是O(n) 的空间复杂度。

通过动画步骤理解算法的复杂度

例子：冒泡排序的可视化

**目标：**对数组 [5, 3, 8, 4, 2] 进行排序。

动画步骤：

初始数组：[5, 3, 8, 4, 2]
第一轮排序：
- **比较 5 和 3：**5 > 3，交换。
  - 数组变为 [3, 5, 8, 4, 2]
- **比较 5 和 8：**5 < 8，不交换。
- **比较 8 和 4：**8 > 4，交换。
  - 数组变为 [3, 5, 4, 8, 2]
- **比较 8 和 2：**8 > 2，交换。
  - 数组变为 [3, 5, 4, 2, 8]
第二轮排序：
- **比较 3 和 5：**3 < 5，不交换。
- **比较 5 和 4：**5 > 4，交换。
  - 数组变为 [3, 4, 5, 2, 8]
- **比较 5 和 2：**5 > 2，交换。
  - 数组变为 [3, 4, 2, 5, 8]
第三轮排序：
- **比较 3 和 4：**3 < 4，不交换。
- **比较 4 和 2：**4 > 2，交换。
  - 数组变为 [3, 2, 4, 5, 8]
第四轮排序：
- **比较 3 和 2：**3 > 2，交换。
  - 数组变为 [2, 3, 4, 5, 8]
排序完成：[2, 3, 4, 5, 8]