玩转算法面试 第二章_算法复杂度分析

第二章 面试中的复杂度分析

2.1 面试中的算法复杂度分析

$n$表示数据规模，$O（f(n)）$表示运行算法所需要执行的指令数，和$f(n)$成正比。

二分查找法	$O（logn）$	所需要执行的指令数：$a\ast logn$
寻找数组中的最大/最小值	$O（n）$	$b\ast n$
归并排序法，快速排序算法	$O（nlogn）$	$c\ast nlogn$
选择排序法，插入排序算法	$O（n^2)$	$d\ast n^2$

在学术界，$O（f(n)）$表示算法执行的上界；在业界，用大$O$来表示算法执行的最低上界。

例如：$O（nlogn+n）=O(nlogn)$

应该注意的是，以上等式的前提是算法处理的两部分的规模n是一样的，在实际中，我们设计的可能是$O（AlogA+B）$，$A$和$B$是没有关系的，此时不能说$AlogA>B$。

例如：用邻接表实现的图进行遍历，时间复杂度：$O（V+E）$，$V$和$E$是两个规模。

一个时间复杂度的问题：

有一个字符串数组，将数组中的每一个字符串按照字母序排序；之后再将整个字符串数组按照字典序排序。整个操作的时间复杂度？

解答：

假设最长的字符串长度为$s$（涵盖最坏的情况，可以得到上界时间复杂度）；数组中有n个字符串。

1.对每个字符串排序：$O（slogs）$；将每个字符串按照字母序排序：$O（n\ast slogs）$

2.将整个字符串数组按照字典序排序：$O（s\ast nlogn）$；排序算法中复杂度$O（nlogn）$的认识：表示的是比较的次数。通常所说两个整型数组进行排序，进行$nlogn$次比较，这是因为整数之间的比较在计算机中的时间复杂度是$O（1）$级别；两个字符串的比较不同，需要看字典序是在前还是在后，比较的过程还需要耗费**O（s）**也就是字符串长度的消耗，所以说的$O（snlogn）$。

整个时间复杂度就是：$O（n\ast slogs+s\ast nlogn）$。

2.2 对数据规模有一个概念

2.2.1 数据规模概念程序实例：

#include "stdafx.h"
#include <math.h>
#include <iostream>
#include <time.h>
using namespace std;
int main()
{
	int x = 0;
	int n = 0;
	for (x = 0; x <= 9; x++){
		n = pow(10, x);
		clock_t start = clock();
		int sum = 0;
		for (int i = 0; i < n; i++) {
			sum = sum + i;
		}
		clock_t end = clock();
		cout << "10^" << x <<":"<< double(end - start) / CLOCKS_PER_SEC << endl;
	}
    return 0;
}

结果可以看到，函数是O（n）级别的复杂度算法。

要想在1s内解决问题：

$O(n)$可以处理大约$10^8$级别的数据；

$O(n^2)$可以处理大约$10^4$级别的数据;

$O(nlogn)$可以处理大约$10^7$级别的数据（$log10^7$约为10）

可以通过数据的多少，确定要设计的时间复杂度预处理。

2.2.2 空间复杂度：

开了多大的辅助空间，就说用了多大的空间复杂度。

多开一个辅助的数组：$O（n）$

多开一个辅助的二维数组：$O（n^2）$

多开常数数组：$O（1）$（原地排序算法，只要开临时的变量）

需要注意的是，递归的调用有空间代价。递归的深度就是递归的复杂度。

2.3 常见的代码模式对应的时间复杂度

$O（1）$：

没有数据规模的变化，例如数的swap函数

$O（n）$：

典型的特征是有一个循环，且循环的次数和$n$相关。基本的时间操作是$c\ast n$次（注意$c$是常数，可以大于1，也可以小于1：例如字符串的swap算法，前面和后面的调换）

$O（n^2）$：

执行的指令数和$n^2$成比例，有两个循环，每重循环都和$n$正相关。例如1：外循环int i=0;i<n;i++，内循环int j=i+1;j<n;j++。此时，执行的指令数是$(n-1)+(n-2)+(n-3)+...+0=1/2\ast n^2-1/2\ast n$，时间复杂度是$O（n^2）$。

但不是每次双重循环都是$O（n^2）$，例如2：外循环int i=0;i<n;i++，内循环int j=1;j<=30;j++。此时第二重循环执行的次数是固定的和$n$无关，总共执行$30n$次操作，时间复杂度为$O（n）$。

例如3：外循环int sz=1;sz<n;sz+=sz，内循环int i=1;i<n;i++，此时外循环是从1开始，每次“乘以2”，最后直到超过n，问题变成了sz经过几次“乘2”最终达到n，时间复杂度$O（logn）$；第二层循环是$O（n）$级别，所以一共是$O（nlogn）$级别。

所以说要注意循环的起始点，中止点，每次的增量变化。

$O（logn）$：

二分查找法是$O（logn）$级别，每次都比较比较元素和中间元素的大小关系，每次丢掉一般的元素，$n\to n/2\to n/4\to ...\to 1$。n经过几次“除以2”的操作以后等于1：$lo{g}_{2}n=O(logn)$。

再例如：$n$经过几次“除以10”的操作以后等于0：$lo{g}_{10}n=O(logn)$。

$lo{g}_{a}n=lo{g}_{a}b\ast lo{g}_{b}n$，所以说以上两个都是$O(logn)$复杂度的。

$O（sqrt（n））$：

循环：int x=2;x*x<=n;x++

2.4 复杂度试验

通过试验，观察变化趋势，每次数据规模提高2倍。

$O（（2n{）}^2）/O（n^2）=4$；$O（2n）/O（n）=2$

此处要注意的是，算法复杂度是$O（logn）$级别的，$log2n/logn=1+log2/logn$，$O（logn）$的复杂度很优秀啊，算法的时间变化很小。启示：顺序查找转换成二分查找。

2.5 递归算法的复杂度分析

不是有递归的函数就一定是$O（logn）$，具体问题具体分析！

递归中进行一次递归调用的时间复杂度分析：

没听懂诶！

归并排序+快速排序

二分查找的递归实现

求和递归实现

计算x的n次方的幂运算

递归中多次进行递归调用，递归树

归并排序

分治算法

2.6 均摊复杂度分析

一个算法的复杂度相对较高，但是这个算法的复杂度是为了方便其他的操作，所以需要将一个算法的复杂度和其他操作的复杂度一起计算，将其均摊到其他算法上去。