【数据结构与算法】笔记--复杂度分析

排版好乱啊

数据结构和算法本身解决的是“快”和“省”的问题，即如何让代码运行得更快，如何让代码更省存储空间。所以，执行效率是算法一个非常重要的考量指标。复杂度分析是整个算法学习的精髓，只要掌握了它，数据结构和算法的内容基本上就掌握了一半。

为什么要进行复杂度分析？

可以直接运行程序得到算法的执行时间和占用内存的大小，但是这样有局限性，首先，测试结果针对不同的硬件有不同的结果。i3的处理器和i9的处理器执行的速度肯定会有差异。其次，测试结果受数据规模的大小的影响。针对小规模数据，插入排序可能比快速排序要快！
针对以上问题，大O表示法应运而生，不用具体的测试数据就能粗略的计算执行效率。

大O表示法

公式：

$T(n)=O(f(n))$
其中，T(n)代表运行时间；n表示数据规模的大小；f(n)表示代码执行的次数总和。O表示执行时间T(n)和f(n)成正比。 大O时间复杂度表示法，实际上并不表示代码的真正的运行时间，而是代码执行时间随数据规模增长的变化趋势，因此，也叫渐进时间复杂度,简称时间复杂度

时间复杂度分析

1、只关注执行次数最多的一段代码

def cal(n):
	sum = 0
	i = 1
	for j in range(n):
		sum += i
	return sum

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

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

def cal(n):
	sum = 0
	i = 1
	for j in range(n):
		sum += i
	
	sum_1 = 0
	q = 1
	p = 1
	for m in range(n):
		p = 1
		for l in range(n):
			sum_1  += p * q
	return sum + sum_1

sum_1 需要运行$O(n^2)$ 所以cal函数运行时间为$O(n)$ +$O(n^2)$，根据加法法则就是$O(n^2)$

3、乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

乘法法则可以看成是嵌套循环

def fun(n):
sum = 0
	i = 1
	for j in range(n):
		sum += fun(i)
return sum

def cal(n):
	sum = 0
	i = 1
	for j in range(n):
		sum += fun(i)
return sum

以上函数时间复杂度表示为：$T(n)=T1(n)\ast T2(n)=O(n\ast n)=O(n^2)$

常见的时间复杂度

常量阶$O(1)$ 对数阶$O(logn)$ 线性阶$O(n)$ 线性对数阶 $O(nlogn)$ 指数阶$O(2^n)$ 阶成阶$O(n!)$

$O(1)$

一般只要算法不含有循环语句，递归语句，即使有上万行代码，时间复杂度依然是$O(1)$

$O(logn)$ $O(nlogn)$

i = 1
while i < n:
	i = i * 2

第三行代码是循环执行次数最多的。所以，我们只要能计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。
从代码中可以看出，变量i的值从1开始取，每循环一次就乘以2。当大于n时，循环结束。变量i的取值就是一个等比数列。

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

i = 1
while i < n:
	i = i * 3

根据刚才分析这段代码的时间复杂度为$O(lo{g}_{3}n)$,实际上，不管是以2为底、以3为底，还是以10为底，我们可以把所有对数阶的时间复杂度都记为$O(logn)$。$lo{g}_{3}n$就等于$lo{g}_{3}2\ast lo{g}_{2}n$，所以$O(lo{g}_{3}n)=O(C\ast lo{g}_{2}n)$，其中$C=lo{g}_{3}2$是一个常量。基于我们前面的一个理论：在采用大O标记复杂度的时候，可以忽略系数，即$O(Cf(n))=O(f(n))$。所以，$O(log_2n) $就等于$O(log_3n)$。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 $O(logn)$。

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

def cal(n, m):
	sum = 0
	i = 1
	for j in range(n):
		sum += i
	
	sum_1 = 0
	p = 1
	for m in range(m):
		sum_1  += p
	return sum + sum_1

从代码中可以看出，m和n是表示两个数据规模。我们无法事先评估m和n谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一个。所以，上面代码的时间复杂度就是$O(m+n)$。

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

空间复杂度分析

空间复杂度全称就是渐进空间复杂度，表示算法的存储空间与数据规模之间的增长关系

为了更能说明问题，用c++表示

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(n2)$，像$O(logn)、O(nlogn)$这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。所以，对于空间复杂度，掌握这些内容已经足够了。

复杂度分析（摘自一个网友的分享）：
1）单段代码看高频：比如循环。
2）多段代码取最大：比如一段代码中有单循环和多重循环，那么取多重循环的复杂度。
3）嵌套代码求乘积：比如递归、多重循环等
4）多个规模求加法：比如方法有两个参数控制两个循环的次数，那么这时就取二者复杂度相加。

附上一篇不错的文章连接在此