复杂度分析-上

大O表示法

代码执行规律：所有代码的执行时间 T(n) 与每行代码的执行次数 n成正比$T(n)=O(f(n))$

T(n) 表示代码执行的时间；n 表示数据规模的大小；f(n) 表示每行代码执行的次数总和。因为这是一个公式，所以用 f(n)来表示。公式中的 O，表示代码的执行时间 T(n) 与 f(n) 表达式成正比。

大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

💡 当 n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。

时间复杂度分析

1.只关注循环执行次数最多的代码

大 O 这种复杂度表示方法只是表示一种变化趋势。我们通常会忽略掉公式中的常量、低阶、系数，只需要记录一个最大阶的量级就可以了。所以，我们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了。这段核心代码执行次数的 n 的量级，就是整段要分析代码的时间复杂度。

例子：

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

其中第 2、3 行代码都是常量级的执行时间，与 n 的大小无关，所以对于复杂度并没有影响。循环执行次数最多的是第 4、5 行代码，所以这块代码要重点分析。这两行代码被执行了 n 次，所以总的时间复杂度就是 O(n)。

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

int cal(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 + j
			i * j;
		}
	}
	return sum_1 + sum_2 + sum_3;
}

第一段的时间复杂度是多少呢？这段代码循环执行了 100 次，所以是一个常量的执行时间，跟 n 的规模无关。

💡 即便这段代码循环 10000 次、100000 次，只要是一个已知的数，跟 n 无关，照样也是常量级的执行时间。当 n 无限大的时候，就可以忽略。尽管对代码的执行时间会有很大影响，但是回到时间复杂度的概念来说，它表示的是一个算法执行效率与数据规模增长的变化趋势，所以不管常量的执行时间多大，我们都可以忽略掉。因为它本身对增长趋势并没有影响。

第二段代码和第三段代码的时间复杂度是 O(n) 和 O(n*2)

综合这三段代码的时间复杂度，取其中最大的量级。整段代码的时间复杂度就为O(n*2)。

将这个规律抽象成公式

$如果 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)*T2(n)=O(f(n))*O(g(n))=O(f(n)*g(n)).$

乘法法则看成是嵌套循环

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

单独看 cal() 函数。假设 f() 只是一个普通的操作，那第 4～6 行的时间复杂度就是，T1(n) = O(n)。但 f() 函数本身不是一个简单的操作，它的时间复杂度是 T2(n) = O(n)，所以，整个 cal() 函数的时间复杂度就是，T(n) = T1(n) * T2(n) = O(nn) = O(n2)。

几种常见时间复杂度实例分析

粗略地分为两类，多项式量级和非多项式量级。其中，非多项式量级只有两个：O(2*n) 和 O(n!)。

当数据规模 n 越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法其实是非常低效的算法。

因此,主要来看几种常见的多项式时间复杂度。

1. O(1)

O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。即便有 3 行，它的时间复杂度也是 O(1），而不是 O(3)。

只要代码的执行时间不随 n 的增大而增长，这样代码的时间复杂度我们都记作O(1)。或者说，一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。

2.$O({\log}\left(n\right))$、$O(n{\log}\left(n\right))$

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

💡 第三行代码是循环执行次数最多的。所以，我们只要能 计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。

变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。实际上，变量 i 的取值就是一个等比数列。如果我把它一个一个列出来，就应该是这个样子的：

所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。通过 2*x=n 求解 x 这个问题我们想高中应该就学过了，我就不多说了。$x={\log}_{2}\left(n\right)$，所以，这段代码的时间复杂度就是 $O({\log}_{2}\left(n\right))$

例：

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

💡 $O({\log}_{3}\left(n\right))$

我们可以把所有对数阶的时间复杂度都记为 $O({\log}\left(n\right))$。

对数之间是可以互相转换的，$O({\log}_{3}\left(n\right))$ 就等于$O({\log}_{3}\left(2\right))$* $O({\log}_{2}\left(n\right))$，所以 $O({\log}_{3}\left(n\right))$=$O(C*{\log}_{2}\left(n\right))$，其中 C=$O({\log}_{3}\left(2\right))$ 是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，$O({\log}_{2}\left(n\right))$ 就等于 $O({\log}_{3}\left(n\right))$。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 $O({\log}\left(n\right))$。

$O(n{\log}\left(n\right))$ :根据乘法法则如果一段代码的时间复杂度是$O({\log}\left(n\right))$，我们循环执行 n 遍，时间复杂度就是$O(n{\log}\left(n\right))$了。而且，$O(n{\log}\left(n\right))$也是一种非常常见的算法时间复杂度。比如，归并排序、快速排序的时间复杂度都是 $O(n{\log}\left(n\right))$。

3.$O(m+n)、O(m*n)$

这种复杂度由两个数据的规模来决定。

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

💡 针对这种情况，原来的加法法则就不正确了，需要将加法规则改为：$T1(m) + T2(n) =O(f(m) + g(n))。$ 但是乘法法则继续有效：$T1(m)*T2(n) = O(f(m) * f(n))$。

空间复杂度分析

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

void print(int n) {
	int i = 0;
	int[] a = new int[n];
	for (i; i <n; ++i) {
		a[i] = i * i;
	}
	for (i = n-1; i >= 0; --i) {
		print out a[i]
	}
}

跟时间复杂度分析一样，我们可以看到，第 2 行代码中，我们申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没有关系，所以我们可以忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。

💡 常见的空间复杂度就是 O(1)、O(n)、O(n)，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多

内容小结

复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率越低。常见的复杂度并不多，从低阶到高阶有：

O(1)、O(logn)、O(n)、O(nlogn)、O(n)。

思考

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

欢迎留言和我分享，我会第一时间给你反馈。