数据结构自学笔记（二）：时间复杂度与空间复杂度

时间复杂度和空间复杂度知识点

一、知识点描述

1. 时间复杂度

   • 核心定义：描述算法时间开销随问题规模$n$增长的趋势，用大O符号表示（忽略常数、低阶项和系数）。
   • 大O规则：
     • 只看最高阶项（如$O(n^2+n)\to O(n^2)$）。
     • 忽略系数（如$O(5n^3)\to O(n^3)$）。
     • 常数项记为$O(1)$（如$O(100)\to O(1)$）。
   • 常见时间复杂度（从小到大排序）：
     • $O(1)$：常数时间，如数组随机访问。
     • $O(\log n)$：对数时间，如二分查找。
     • $O(n)$：线性时间，如数组遍历。
     • $O(n\log n)$：线性对数时间，如归并排序。
     • $O(n^2)$：平方时间，如冒泡排序。
     • $O(2^n)$：指数时间，如递归斐波那契。
     • $O(n!)$：阶乘时间，如全排列枚举。
   • 求解步骤：
     • 定位基本操作（执行次数最多的语句）。
     • 计算执行次数$f(n)$（分析$n$的影响）。
     • 化简为大O（保留最高阶项）。
   • 示例关键点：
     • 遍历数组求和：基本操作执行$n$次，$f(n)=n\to O(n)$。
     • 嵌套循环：基本操作执行$n^2$次，$f(n)=n^2\to O(n^2)$。
     • 二分查找：每次规模减半，执行约${\log }_{2}n$次，$f(n)=\log n\to O(\log n)$。

2. 空间复杂度

   • 核心定义：描述算法额外空间开销（不包括输入数据）随$n$增长的趋势，用大O符号表示。
   • 原地工作：额外空间为常量时，空间复杂度为$O(1)$。
   • 常见空间复杂度：
     • $O(1)$：原地工作，如冒泡排序。
     • $O(n)$：线性空间，如新建数组或递归深度$n$。
     • $O(n^2)$：平方空间，如新建$n\times n$矩阵。
   • 求解步骤：
     • 分析额外空间（变量、数据结构、递归栈等）。
     • 找出空间与$n$的关系$f(n)$。
     • 化简为大O（保留主导项）。
   • 示例关键点：
     • 冒泡排序：仅用1个临时变量，$f(n)=1\to O(1)$。
     • 新建数组：申请$n$个元素空间，$f(n)=n\to O(n)$。
     • 递归阶乘：递归深度$n$，栈空间$f(n)=n\to O(n)$。

3. 时间与空间权衡

   • 核心思想：两者均关注“趋势”，而非精确值；设计算法时需根据场景取舍。
   • 权衡策略：
     • 时间换空间：如链表（插入/删除快，但遍历慢）。
     • 空间换时间：如哈希表（用额外空间加速查找）。
   • 设计原则：对时间敏感场景优先优化时间复杂度，对空间敏感场景优先优化空间复杂度。

4. 学习技巧

   • 推导方法：从代码出发，定位基本操作和额外空间，逐步推导复杂度。
   • 对比分析：比较不同算法的复杂度（如冒泡排序$O(n^2)$ vs 归并排序$O(n\log n)$），理解效率差异。
   • 实践应用：结合实际问题（如大数据量选算法），强化复杂度感知。

5. 示例

示例1：遍历数组求和（$O(n)$）

int sum = 0;
for(int i=0; i<n; i++){
    sum += arr[i]; // 基本操作，执行n次 → f(n)=n → O(n)
}

示例2：嵌套循环（$O(n^2)$）

for(int i=0; i<n; i++){
    for(int j=0; j<n; j++){
        printf("%d", arr[i][j]); // 执行n²次 → f(n)=n² → O(n²)
    }
}

示例3：二分查找（$O(\log n)$）

int binarySearch(int arr[], int n, int target){
    int left=0, right=n-1;
    while(left <= right){
        int mid = (left+right)/2; // 每次规模减半，执行≈log₂n次 → O(logn)
        ...
    }
}

二、空间复杂度

1. 核心定义

• 描述：算法额外空间开销（不包括输入数据）随$n$增长的趋势。
• 原地工作：额外空间为常量时，空间复杂度$O(1)$。

2. 常见空间复杂度

复杂度	含义	典型场景
$O(1)$	原地工作	冒泡排序
$O(n)$	线性空间	新建数组
$O(n^2)$	平方空间	新建二维矩阵

3. 求解步骤

1. 分析额外空间：统计算法内部空间（如变量、数据结构、递归栈）。
2. 找出关系：得到空间表达式$f(n)$。
3. 化简为大O：保留主导项。

4. 示例

示例1：冒泡排序（$O(1)$）

void bubbleSort(int arr[], int n){
    for(int i=0; i<n; i++){
        for(int j=0; j<n-i-1; j++){
            if(arr[j]>arr[j+1]){
                int temp = arr[j]; // 仅1个临时变量 → f(n)=1 → O(1)
                ...
            }
        }
    }
}

示例2：新建数组（$O(n)$）

int* squareArray(int arr[], int n){
    int* res = new int[n]; // 申请n个元素空间 → f(n)=n → O(n)
    ...
}

示例3：递归阶乘（$O(n)$）

int factorial(int n){
    if(n==0) return 1;
    return n * factorial(n-1); // 递归深度n → 栈空间f(n)=n → O(n)
}

三、时间与空间权衡

1. 核心思想

• 关注“趋势”，而非精确值；设计时需取舍（如时间敏感优先优化时间复杂度）。

2. 权衡策略

• 时间换空间：链表（插入/删除快，遍历慢）。
• 空间换时间：哈希表（额外空间加速查找）。

四、学习技巧

1. 推导练习：从代码定位基本操作和额外空间，推导$f(n)$并化简。
2. 对比算法：比较复杂度差异（如冒泡$O(n^2)$ vs 归并$O(n\log n)$）。
3. 实际问题应用：针对场景选择算法（如大数据量优先$O(n\log n)$）。