前面我们已经介绍了,研究算法的最终目的就是如何花更少的时间,如何占用更少的内存去完成相同的需求,并且 也通过案例演示了不同算法之间时间耗费和空间耗费上的差异,但我们并不能将时间占用和空间占用量化,因此， 接下来我们要学习有关算法时间耗费和算法空间耗费的描述和分析。有关算法时间耗费分析,我们称之为算法的时 间复杂度分析,有关算法的空间耗费分析,我们称之为算法的空间复杂度分析。
1.算法的时间复杂度分析
计算算法时间消耗情况，首先得度量算法的执行时间，如何测量呢？
事后分析估算方法：
比较容易想到的方法就是我们把算法执行若干次，然后那个计时器在旁边计时，这种事后统计的方法看上去的确不错，并且也并非要我们真的那个计算器在旁边就散，因为计算机都提供给了计时功能。这种统计方法主要通过设计好的测试程序和测试数据，利用计算机计时器对不同的算法编制的程序的运行时间进行比较，从而确定算法效率的高低，但是这种方法有很大的缺陷；必须一句算法是爱安编制好的测试程序，通常要话费大量时间和精力，测试完了如果发现测试的是非常糟糕的算法，那么之前所做的事情就全部白费了，并且不同的测试环境的差别导致的结果差异也很大。
public static void main(String[] args) {
long start = System.currentTimeMillis();
int sum = 0; int n=100;
for (int i = 1; i <= n; i++) {
sum += i;
}
System.out.println("sum=" + sum);
long end = System.currentTimeMillis();
System.out.println(end-start);
}事前分析估算方法：
在计算机程序编码钱，依据统计方法对算法进行估算，胫骨总结，我们发现一个高级语言编写的程序在计算机上运行所消耗的时间取决于下列因素：
算法采用的策略和方案；
编译产生的代码质量；
问题输入规模；
机器执行指令的速度。
由此可见，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。如果算法固定，那么该算法的执行时间就只和问题的输入规模有关了。
需求：计算1到100的和。
因此，当输入规模为n时，第一种算法执行了2n+3次；第二种执行了3次，如果我们把第一种算法的循环体看做是一个整体，忽略结束条件的判断，那么其实这两个算法运行时间的差距就是n和1的差距。
为什么循环判断在算法1里执行了n+1次，看起来是个不小的数量，但是的确可以忽略？
需求：计算100 个（1到100）的结果。
如果我们要精确的研究循环条件执行了多少次，是一件很麻烦的事情，并且，由于真正计算和的代码是内循环的循环体，所以，在研究算法的效率时，我们只考虑核心代码的执行次数，这样可以简化分析。我们研究算法复杂度，侧重的是当前输入规模不断增大时，算法的增长量的一个抽象，而不是精确地定位需要执行了多少次，因为如果这样的话，我们又得开率编译器优化等问题。
我们不关心编写程序所用的什么语言，也不关心这些程序跑在什么机器上，我们只关心它所实现的算法。这样，不计哪些循环索引的递增和循环终止的条件、变量声明、打印结果等操作，最终在分析程序的运行时间时，最重要的是把程序看做是独立于程序设计语言的算法或一系列步骤。我们分析一个算法的运行时间，最重要的就是把核心操作的次数和输入规模练习起来。
1.1函数渐近增长
概念：给定两个函数f(n)和g(n),如果存在一个整数N，使得对于所有的n>N,f(n)总是比g(n)大，那么就说f(n)的增长渐近快于g(n).
做一些测试帮助理解。
测试一：
假设四个算法的输入规模都是n:
1.算法A1要做2n+3次操作，可以这么理解；先执行n次循环，执行完毕后，再执行一个n次循环，最后有3次运算；
2.算法A2要做2n次操作；
3.算法B1要做3n+1次操作，可以这么理解：先执行n次循环，再执行n次循环，再执行n次循环，最后1次运算；
4.算法B2要做3n次操作。
那么，上述算法，哪个更快一些呢？
| 输入规模 | 算法Al(2n+3)执行次数 | 算法A2(2n)执行次数 | 算法Bl(3n+1)执行次数 | 算法B2(3n)执行次数 |
| n=l | 5 | 2 | 4 | 3 |
| n=2 | 7 | 4 | 7 | 6 |
| n=3 | 9 | 6 | 10 | 9 |
| n=10 | 23 | 20 | 31 | 30 |
| n=100 | 203 | 200 | 301 | 300 |
通过数据表格,比较算法A1和算法B1 :
当输入规模n=1时,A1需要执行5次,B1需要执行4次,所以A1的效率比B1的效率低；
当输入规模n=2时,A1需要执行7次,B1需要执行7次,所以A1的效率和B1的效率一样；
当输入规模n>2时,A1需要的执行次数一直比B1需要执行的次数少,所以A1的效率比B1的效率高。
结论：当输入规模n>2时，算法A1的渐近增长小于算法B1的渐近增长 通过观察折线图,我们发现,随着输入规模的增大,算法A1和算法A2逐渐重叠到一块,算法B1和算法B2逐渐重叠 到一块，所以我们得出结论：随着输入规模的增大，算法的常数操作可以忽略不计。
测试二：
假设四个算法的输入规模都是n：
1算法C1需要做4n+8次操作；
2算法C2需要做n次操作；
3算法D1需要做2n^2次操作；
4算法D2需要做n*2次操作；
那么上述算法,哪个更快一些?
| 输入规模 | 算法Cl(4n+8)执行次数 | 算法C2(n)执行次数 | 算法Dl(2n¥+1)执行次数 | 算法D2(n^2)执行次数 |
| n = l | 12 | 1 | 3 | 1 |
| n=2 | 16 | 2 | 9 | 4 |
| n=3 | 20 | 3 | 19 | 9 |
| n=10 | 48 | 10 | 201 | 100 |
| n=100 | 408 | 100 | 20001 | 10000 |
| n=1000 | 4008 | 1000 | 2000001 | 1000000 |
通过数据表格，对比算法C1和算法D1 :
当输入规模n<=3时，算法C1执行次数多于算法D1 ,因此算法C1效率低一些；
当输入规模n>3时,算法C1执行次数少于算法D1 ,因此，算法D2效率低一些,
所以,总体上,算法C1要优于算法D1,
通过折线图，对比对比算法C1和C2 :
随着输入规模的增大,算法C1和算法C2几乎重叠
通过折线图，对比算法C系列和算法D系列：
随着输入规模的增大,即使去除”2前面的常数因子,D系列的次数要远远高于C系列。
因此,可以得出结论：
随着输入规模的增大，与最高次项相乘的常数可以忽略
...
最高次项的指数大的，随着n的增长,结果也会变得增长特别快
1.2算法时间复杂度
1.2.1大O记法
定义：在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随着n的变化情况并确定T(n)的 量级。算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))。它表示随着问题规模n的增大，算法执行时间 的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度，其中f(n)是问题规模n的某个函数。
public static void main(String[] args) {
int sum = 0;//执行1次
int n=100;//执行1次
sum = (n+1)*n/2;//执行1次
System.out.println("sum="+sum);
} public static void main(String[] args) {
int sum = 0;//执行1次
int n=100;//执行1次
for (int i = 1; i <= n; i++) {
sum += i;//执行了n次
}
System.out.println("sum=" + sum);
}public static void main(String[] args) {
int sum=0;//执行1次
int n=100;//执行1次
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=n ; j++) {
sum+=i;//执行n^2次
}
}System.out.println("sum="+sum);
}1.2.2常见的大O阶
线性阶：一般含有非嵌套循环涉及线性阶，线性阶就是随着输入规模的扩大，对应计算次数呈直线增长，例如：
public static void main(String[] args) {
int sum=0,n=100;
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=n ; j++) {
sum+=i;
}
}
System.out.println(sum);
}平方阶：一般嵌套循环属于这种时间复杂度
public static void main(String[] args) {
int sum = 0;
int n=100;
for (int i = 1; i <= n; i++) {
sum += i;
}
System.out.println("sum=" + sum);
}上面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环 中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2).
立方阶：一般三层嵌套循环属于这种时间复杂度
public static void main(String[] args) {
int x=0,n=100;
for (int i = 1; i <=n ; i++) {
for (int j = i; j <=n ; j++) {
for (int j = i; j <=n ; j++) {
x++;
}
}
}
System.out.println(x);
}上面这段代码，n=100，也就是说，外层循环每执行一次，中间循环循环就执行100次，中间循环每执行一次，最 内层循环需要执行100次，那总共程序想要从这三个循环中出来，就需要执行100100100次，也就是n的立方，所以这段代码的时间复杂度是O(n^3).
对数阶：对数，属于高中数学的内容，我们分析程序以程序为主，数学为辅，所以不用过分担心。
int i=1,n=100;
while(i<n){
i = i*2;
}| 输入规模 | log(2)n | log(4)n | log(8)n |
| 8 | 3 | 1.5 | 1 |
| 64 | 6 O | 3 | 2 |
| 512 | 9 | 4.5 | 3 |
| 4096 | 12 | 6 | 4 |
| 16777216 | 24 | 12 | 8 |
| 134217728 | 27 | 13.5 | 9 |
| 2.815E+14 | 48 | 24 | 16 |
| 7.923E+28 | 96 | 48 | 32 |
| 6.28E+57 | 192 | 96 | 64 |
| 3.94E+115 | 384 | 192 | 128 |
| 1.55E+231 | 768 | 384 | 256 |
public static void main(String[] args) {
int n=100;
int i=n+2;
System.out.println(i);
}上述代码，不管输入规模n是多少，都执行2次，根据大O推导法则，常数用1来替换，所以上述代码的时间复杂度为O(1)。
总结：
| 描述 | 增长的数量级 | 说明 | 举例 |
| 常数级别 | [ | 普通语句 | 将两个数相加 |
| 对数级别 | logN | 二分策略 | 二分查找 |
| 线性级别 | N | 循环 | 找出取大7 b糸 |
| 线型对数级别 | NIogN | 分治思想 | 归并排序 |
| 平方级别 | NA2 | 谯循环 | 检查所有元素对 |
| 立方级别 | NA3 | 圭循环 | 检查所有三元组 |
| 指数级别 | 2AN | 穷举查找 | 检查所有子集 |
复杂程度从低到高依次为：0(1 )<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^3)。
根据前面的折线图分析,我们会发现,从平方阶开始,随着输入规模的增大，时间成本会急剧增大,所以,我们的 算法,尽可能的追求的是O(1),O(logn),O(n),O(nlogn)这几种时间复杂度，而如果发现算法的时间复杂度为平方阶、 立方阶或者更复杂的,那我们可以分为这种算法是不可取的,需要优化。
1.2.3函数调用的时间复杂度分析
之前,我们分析的都是单个函数内,算法代码的时间复杂度,接下来我们分析函数调用过程中时间复杂度。
public static void main(String[] args) {
int n=100;
for (int i = 0; i < n; i++) {
show(i);
}
}
private static void show(int i) {
System.out.println(i);
}在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部只执行了一行代码，所以show方法的时间复杂度为O(1),那main方法的时间复杂度就是O(n)。
public static void main(String[] args) {
int n=100;
for (int i = 0; i < n; i++) {
show(i);
}
}
private static void show(int i) {
for (int j = 0; j < i; i++) {
System.out.println(i);
}
}在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部也有一个for循环，所以show方法 的时间复杂度为O(n),那main方法的时间复杂度为O(n^2)。
public static void main(String[] args) {
int n=100; show(n);
for (int i = 0; i < n; i++) {
show(i);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.println(j);
}
}
}
private static void show(int i) {
for (int j = 0; j < i; i++) {
System.out.println(i);
}
}在show方法中，有一个for循环，所以show方法的时间复杂度为O(n),在main方法中，show(n)这行代码内部执行 的次数为n，第一个for循环内调用了show方法，所以其执行次数为n^2,第二个嵌套for循环内只执行了一行代码，
1.2.4最坏情况
从心理学角度讲，每个人对发生的事情都会有一个预期，比如看到半杯水，有人会说：哇哦，还有半杯水哦！但也 有人会说：天哪，只有半杯水了。一般人处于一种对未来失败的担忧，而在预期的时候趋向做最坏的打算，这样即 使最糟糕的结果出现，当事人也有了心理准备，比较容易接受结果。假如最糟糕的结果并没有出现，当事人会很快乐。
public int search(int num){
int[] arr={11,10,8,9,7,22,23,0};
for (int i = 0; i < arr.length; i++) {
if (num==arr[i]){ return i;
}
}
return -1;
}2.算法的空间复杂度分析
计算机的软硬件都经历了一个比较漫长的演变史，作为为运算提供环境的内存，更是如此，从早些时候的512k,经 历了1M，2M，4M...等，发展到现在的8G，甚至16G和32G，所以早期，算法在运行过程中对内存的占用情况也是 一个经常需要考虑的问题。我么可以用算法的空间复杂度来描述算法对内存的占用。
1.2.1Java中常见的内存占用
| 数据类型 | 内存占用字节数 |
| byte | [ |
| short | 2 |
| int | 4 |
| long | 8 |
| float | 4 |
| double | 8 |
| boolean | [ |
| char | 2 |
一个引用（机器地址）需要8个字节表示。
1.2.2算法的空间复杂度
了解了java的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。
算法的空间复杂度计算公式记作：S(n)=O(f(n)),其中n为输入规模，f(n)为语句关于n所占存储空间的函数。
需求：对指定的数组元素进行反转，并返回反转的内容。
public static int[] reverse1(int[] arr){
int n=arr.length;//申请4个字节
int temp;//申请4个字节
for(int start=0,end=n-1;start<=end;start++,end--){
temp=arr[start];
arr[start]=arr[end];
arr[end]=temp;
}
return arr;
} public static int[] reverse2(int[] arr) {
int n = arr.length;//申请4个字节
int[] temp = new int[n];
//申请n*4个字节+数组自身头信息开销24个字节
for (int i = n - 1; i >= 0; i--) {
temp[n - 1 - i] = arr[i];
}
return temp;
}
2910
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
