【LeetCode Cookbook（C++ 描述）】时间复杂度与空间复杂度

本系列文章仅是 GitHub 大神 @halfrost 的刷题笔记 《LeetCode Cookbook》的提纲以及示例、题集的 C++转化。原书请自行下载学习。

时间复杂度的数据规模

• 1 s 内能解决问题的数据规模：10⁶ ～10⁷

数据规模	时间复杂度	算法举例
10	$O(n!)$	$permutation$ 排列（旅行推销员问题）
20～30	$O(2^n)$	$combination$ 组合
50	$O(n^4)$	DFS 搜索、DP 动态规划
100	$O(n^3)$	任意两点最短路径、DP 动态规划
1000	$O(n^2)$	稠密图、DP 动态规划
106	$O(n\log n)$	排序、堆（$heap$）、递归与分治
107	$O(n)$	DP 动态规划、图遍历、拓扑排序、树遍历
109	$O(\sqrt{n})$	筛素数、求平方根
1010	$O(\log n)$	二分搜索（查找）
$+\infty$	$O(1)$	数学相关算法

一些具有迷惑性的例子

void hello(int n) {
    for (int sz = 1; sz < n; sz += sz)
        for (int i = 0; i < n; i++) 
        	cout << "Hello" << endl; 
}

❗️易错点：该例子的时间复杂度为$O(n\log n)$ 而非 $O(n^2)$ 。

补全代码结构，传入参数 $n=5$，最终输出共 $15=5\times 3$ 个 Hello 。

不难理解，这一函数的内层循环是简单的从 0 到 $n-1$ 的循环，总是执行 $n$ 次；

而对于外层循环，每一次迭代 sz 都会翻倍（此时 sz += sz 等同于 sz *= 2），这实际上是一个以 2 为指数增长的循环。假设外层循环执行了$k$ 次，则第$k$ 次迭代后，sz 的值至少为$2^k$ ，根据循环条件，sz $\ge$ 0 时循环终止，则$k$ 应满足 $2^k\ge n$，两边同时取对数，不难得出$k\ge {\log }_{2}n$。考虑到程序实际运行情况，外层循环实际执行的次数应为$\lfloor {\log }_{2}n\rfloor +1$ （例如，上述传参情况下，$n=5$，外层循环执行了$\lfloor {\log }_{2}5\rfloor +1$ 即$2+1=3$ 次）。

综上所述，由乘法原理，总的时间复杂度为$(\lfloor {\log }_{2}n\rfloor +1)\times n$，考虑到$\lfloor {\log }_{2}n\rfloor$ 是小于等于${\log }_{2}n$ 的最大整数，并且常数项在复杂度分析中一般被忽略，则该算法的时间复杂度的大 $O$ 标记法为$O(n\log n)$。

另一个例子：

bool isPrime(int n) {
    for (int x = 2; x * x <= n; x++)
        if (n % x == 0) return false;
    return true;
}

❗️易错点：该例子的时间复杂度为$O(\sqrt{n})$ 而非 $O(n)$ 。

这是一个判断输入参数是否为质数的算法，例如 $n=2$ 时返回 true（2 为质数），$n=4$ 时则返回 false。

实现简单粗暴地判断质数的朴素方法是遍历 2 到$n-1$ 的所有整数，判断是否存在能整除$n$ 的整数：

bool isPrime(int n) {
    for (int i = 2; i <= n - 1; i++)
        if (n % i == 0) return false;
    return true;
}

对此我们十分熟悉，对于一个整数，我们需要$n-2$ 次判断，很快就能得出其时间复杂度为$O(n)$，但这种算法在 $n$ 较大的情况下是不可取的，并非是最优解。

对于一个小于 $n$ 的整数 $x$，如果 $n$ 不能整除 $x$，则 $n$ 必然不能整除于 $\frac{n}{x}$。按照这样的思路，我们从 2 枚举到 $\sqrt{n}$ 即可，判断 2 的同时也判断了 $\frac{n}{2}$，……，以此类推，到 $\sqrt{n}$ 的时候就已经全部判断完毕了，便可以得出本例子的解法。那么，本例子的时间复杂度也就呼之欲出了，对于一个整数，需要$\sqrt{n}-1$ 次判断，即$O(\sqrt{n})$。

或者，还可以注意到，当 $x>\sqrt{n}$ 时，$x\times x$ 一定大于 $n$，从而循环终止。

本例子中，我们用$x\times x\le n$ 代替$x\le \sqrt{n}$ 是为了避免 sqrt() 函数的调用，其在大量数据测试中时间消耗较为明显。实际上，判断质数的算法中仍有优于此种解法的，详情请见 @zz09 的这篇文章。

更多例子

有一个字符串数组，将数组中的每一个字符串按照字母序排序，之后再将整个字符串数组按照字典
序排序。假设数组中有 $n$ 个字符串，最长的字符串的长度为 $s$，则其时间复杂度为$O(ns(\log s+\log n))$ 而非$O(n^2\log n+n\log n)=O(n^2\log n)$。

误区在于，字符串的长度与数组的长度是没有关系的，所以这两个变量应当单独计算。对一个字符串排序的时间复杂度为$O(s\log s)$，推广到每一个数组中的字符串则为$O(ns\log s)$。

要使整个字符串数组按照字典序排序，则先通过排序算法比较$O(n\log n)$ 次，每次比较耗费$O(s)$，整个过程中时间复杂度为$O(sn\log n)$。

因此，整体的时间复杂度为两个过程之和即$O(ns(\log s+\log n))$。

空间复杂度

• 递归调用是有空间代价的，递归算法需要保存递归栈信息，所以花费的空间复杂度会比非递归算法要高。

递归的时间复杂度

一次递归调用

如果递归函数中，只进行了一次递归调用，且递归深度为 $depth$，在每个递归函数中，时间复杂度为 $T$，那么总体的时间复杂度为 $O(T\times depth$)。

/// @brief The recursive implementation of binary search
/// @param arr Given array
/// @param l Lower bound
/// @param r Upper bound
/// @param target Given num
/// @return The index of target
int binarySearch(int arr[], int l, int r, int target {
  if( l > r)
    return -1;
  int mid = l + (r - l)/2; // 防止溢出
  if(arr[mid] == target)
    return mid;
  else if (arr[mid] > target)
    return binarySearch(arr, l, mid - 1, target);
  else
    return binarySearch(arr, mid + 1, r, target);
}

在二分查找的递归实现中，每次递归调用都能将搜索区间减半，则递归深度最多为 ${\log }_{2}n$ 次，每次递归中时间复杂度均为$O(1)$，那么总的时间复杂度为$O(\log n)$。

多次递归调用

int f(int n) {
    assert(n >= 0);
    if(n ==0)
        return 1;
    return f( n - 1 ) + f ( n - 1 );
}

直接计算所有递归调用的次数，基本上是等比数列求和，时间复杂度为$2^0+2^1+2^2+...+2^n=2^{n-1}=O(2^n)$ 。

关于更加复杂的递归的复杂度分析，请参考主定理（$MasterTheorem$）。主定理中针对各种复杂情况都给出了正确的结论。