数据结构和算法笔记-算法分析

一、算法分析

研究算法的最终目的就是如何花费更少的时间，占有更少的内存空间去完成相同的需求。这时我们需要去量化时间和空间，就是给算法所需的时间和空间一把标度尺来描述时间和空间的大小。

一般而言，有关算法时间耗费分析，我们称之为算法的时间复杂度分析；有关算法的空间耗费分析，我们称之为算法的空间复杂度分析。

1.1 算法的时间复杂度分析

估算时间复杂度又两种方法：一种是事后分析估算法，另一种是事前分析估算法。

事后分析估算方法:（事后诸葛亮，，事前猪一样，不好）
  比较容易想到的方法就是我们把算法执行若干次，然后拿个计时器在旁边计时，这种事后统计的方法看上去的确不错，并且也并非要我们真的拿个计算器在旁边计算，因为计算机都提供了计时的功能。这种统计方法主要是通过设计好的测试程序和测试数据，利用计算机计时器对不同的算法编制的程序的运行时间进行比较，从而确定算法效率的高低。
但是这种方法有很大的缺陷∶必须依据算法实现编制好的测试程序，通常要花费大量时间和精力，测试完了如果发现测试的是非常糟糕的算法，那么之前所做的事情就全部白费了，并且不同的测试环境(硬件环境)的差别导致测试的结果差异也很大。

public static void main(string[] args）{
	long start = system.currentTimeillis(;
	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. 算法采用的策略和方案;（程序员可以干预的）
   如：我要去北京，有什么策略方法
2. 问题的输入规模(所谓的问题输入规模就是输入量的多少)；（这个我们可以由需求干预）
   如：求1 ~ 100的和，100就是输入规模；又如：求1 ~1亿的和，1亿就是输入规模
3. 编译产生的代码质量;（程序员不考虑）
   编译器编译产生的文件代码质量如何，会对算法有影响
4. 机器执行指令的速度;（程序员不考虑）
   java中jdm去执行指令的速度。

  由此可见，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。如果算法固定，那么该算法的执行时间就只和问题的输入规模有关系了。

  我么再次以之前的求和案例为例，进行分析。

   计算1到100的和。

• 第一种解法

public static void main(string[] args){
	int sum = 0;//执行1次
	int n=100;//执行1次
	for (int i = 1; i <= n; i++) {//执行n+1次
		sum += i;//执行n次
	}
	system.out.println("sum=" + sum);
}

• 第二种解法

public static void main(string[]args){
	int sum = e;//执行1次
	int n=100;//执行1次
	sum = (n+1)*n/2;//执行1次
	system.out.println(""sum="+sum);
}

  分析上面的两种解法，我们可以得到，当输入规模为n时，第一种算法执行了1+1+(n+1)+n=2n+3次;第二种算法执行了1+1+1=3次。

  在算法估算中，通常只考虑核心代码的执行次数，忽略那些循环索引，打印结果、变量声明的执行次数。
如果我们把第一种算法的循环体看做是一个整体，忽略结束条件 (for循环的i) 的判断，那么其实这两个算法运行时间的差距就是n和1的差距。

由上图，我们很直观的就可以看出来，橙色直线的算法明显由于红色直线代表的算法。

1.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次操作;

上面各个算法的操作就可以理解为描述算法时间复杂度的函数。（这里的函数并不是最终的表示算法时间复杂度的函数）

思考上述算法，哪一个更快—些呢?这里就可以利用到函数的渐近增长来作出判断了。

通过数据表格,比较算法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逐渐重叠到一块。A1与A2，B1与B2的差别就只是一个常数项的不同，所以我们得出结论:
  随着输入规模的增大，算法的常数操作可以忽略不计

例子二∶
假设四个算法的输入规模都是n:

1. 算法C1需要做4n+8次操作
2. 算法C2需要做n次操作
3. 算法D1需要做2n^2次操作
4. 算法D2需要做n^2次操作

那么上述算法，哪个更快—出?

通过数据表格，对比算法C1和算法D1:
  当输入规模n<=3时，算法C1执行次数多于算法D1，因此算法C1效率低一些;
  当输入规模n>3时，算法C1执行次数少于算法D1，因此，算法D1效率低一些，
所以，总体上，算法C1要优于算法D1.

通过折线图，对比对比算法C1和C2:
  随着输入规模的增大，算法C1和算法C2几乎重叠
通过折线图，对比算法C系列和算法D系列:
  随着输入规模的增大，即使去除n^2前面的常数因子，D系列的次数要远远高于C系列。

因此，可以得出结论:
  随着输入规模的增大，与最高次项相乘的常数可以忽略

例子三

通过数据表格，对比算法E1和算法F1:
  当n=1时，算法E1和算法F1的执行次数一样;
  当n>1时，算法E1的执行次数远远小于算法F1的执行次数;
  所以算法E1总体上是优于算法F1的。

通过折线图我们会看到，算法F系列随着n的增长会变得特块，算法E系列随着n的增长相比较算法F来说，变得比较慢，所以可以得出结论︰
  最高次项的指数大的，随着n的增长，结果也会变得增长特别快

例子四

通过观察数据表格和折线图，很容易可以得出结论∶
  算法函数中n最高次幂越小，算法效率越高

结论：
总上所述，在我们比较算法随着输入规模的增长量时，可以有以下规则:
1.算法函数中的常数可以忽略;
2.算法函数中最高次幂的常数因子可以忽略;
3.算法函数中最高次幂越小，算法效率越高。

1.1.2 算法时间复杂度

算法时间复杂度重点是 函数的核心操作与我们输入规模n的关系。通过函数渐近增长的学习，我们学习到什么才是真正影响我们函数增长速率的。下面我们讨论复杂度的表示方法。

1.1.3 大O记法

定义:

在这里，我们需要明确一个事情：执行次数=执行时间

在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随着n的变化情况并确定T(n)的量级。算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))。它表示随着问题规模n的增大，算法执行时间的增长率和fin)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度，其中f(n)是问题规模n的某个函数。

用大写O()来体现算法时间复杂度的记法，我们称之为大O记法。一般情况下，随着输入规模n的增大，T(n)增长最慢的算法为最优算法。

理清T(n),f(n),O(f(n))之间的关系

• n是什么？
  可以理解n是的问题规模。假设每条语句执行一次所需的时间均是单位时间，则一个算法的执行时间可用该算法中所有语句的执行次数之和来表示。（这里的语句执行的次数也称为语句的频度）
• f(n)是什么？
  f(n)是指算法中所有语句频度之和。
• T(n)是什么？
  T(n)是算法的时间量度。
  
  它表示随问题规模n的增大， 算法执行时间的增长率 和 f(n)的增长率相同， 也称做算法的渐近时间复杂度， 简称时间复杂度(TimeComplexity)。
• O(f(n))是什么?
  O表示的是数量级。数量级是以所有的语句频度为衡量标准的
  符号"O"用来描述增长率的上限，它表示当问题规模n>n₀时，算法的执行时间不会超过f(n)。
  
  这个O遵循一下的定理（即根据O的定义定下的道理）：
  
  这个定理1.1是在说明， 在计算算法时间复杂度时， 可以忽略所有低次幕项和最高次幕的系数， 这样可以简化算法分析， 也体现出了增长率的含义。（影响增长率的最主要因素是最高次幂）
  定理1.1表明使用大O表示法表示时间复杂度时，可以使用以下的规则

下面我们使用大O 表示法来表示—些求和算法的时间复杂度∶
算法—:

public static void main(string[]args){
	int sum = 0;//执行1次
	int n=100;//执行1次
	sum = (n+1)*n/2;//执行1次
	system.out.printlnTsum（""+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=180;//执行1次
	for (int i = 1; i <=n ; i+t){
		for (int j = 1;j<=n ; j++){
			sum+=i;//执行n^2次
		}
	}
	system.out.println("sum=""+sum);
}

如果忽略判断条件的执行次数和输出语句的执行次数，那么当输入规模为n时，以上算法执行的次数分别为:

  算法一∶3次
  算法二：n+3次
  算法三：n²+2次

如果用大O记法表示上述每个算法的时间复杂度，应该如何表示呢?基于我们对函数渐近增长的分析，推导大O阶的表示法有以下几个规则可以使用∶

1. 用常数1取代运行时间中的所有加法常数;
2. 在修改后的运行次数中，只保留高阶项;
3. 如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数;

所以上述算法的时间复杂度分别是：
  算法一∶O(1)
  算法二：O(n)
  算法三：O(n²)

1.1.4 常见的大O阶

1.线性阶

一般含有非嵌套循环涉及线性阶，线性阶就是随着输入规模的扩大，对应计算次数呈直线增长，例如:

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);
}

上面这段代码，它的循环的时间复杂度为O(n),因为循环体中的代码需要执行n次

2.平方阶

—般嵌套循环属于这种时间复杂度

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++){
			sumi=i;//核心代码
		}
	}
	system.out.println(sum);
}

上面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2).

3.立方阶

—般三层嵌套循环属于这种时间复杂度

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³)

4.对数阶（重点理解）

对数，属于高中数学的内容，我们分析程序以程序为主，数学为辅.

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

由于每次 i*2 之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到 x=log₂n ，所以这个循环的时间复杂度为O(log₂n);

对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以我们会忽略底数。

5.常数阶

一般不涉及循环操作的都是常数阶，因为它不会随着n的增长而增加操作次数。例如∶

public static void main(string[]args){
	int n=100;
	int i=n+2;
	system.out.printin(i);
}

上述代码，不管输入规模n是多少，都执行2次，根据大O推导法则，常数用1来替换，所以上述代码的时间复杂度为O(1)

总结

他们的复杂程度从低到高依次为∶
O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³)
根据前面的折线图分析，我们会发现，从平方阶开始，随着输入规模的增大，时间成本会急剧增大，所以，我们的算法，尽可能的追求的是O(1)O(logn)O(n)O(nlogn)这几种时间复杂度，而如果发现算法的时间复杂度为平方阶 O(n²)、立方阶O(n³)或者更复杂的，那我们可以分为这种算法是不可取的，需要优化。

1.1.5 函数调用的时间复杂度

之前，我们分析的都是单个函数内，算法代码的时间复杂度，接下来我们分析函数调用过程中时间复杂度。

案例一：

public static void main(string[]args) {
	int n=100;
	for (int i = o; i < n; i++) {
	show(i);
	}
	private static void show(int_i){
	system.out.printin(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; irt){
		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²)

案例三:

public static void main(string[]args）{
	int n=100;
	show(n);
	for (int i = o; i < n; i++) {
		show(i);
	}
	for (int i = e; i <n; i++) {
		for (int j = 0; j <n; j++){
			system.out.println(j);
	}
}
private static void show(int i) {
	for (int j = o; j < i; i++){
	system.out.println(i);
	}
}

在show方法中，有一个for循环，所以show方法的时间复杂度为O(n),在main方法中，show(n)这行代码内部执行的次数为n，第一个for循环内调用了show方法，所以其执行次数为n2,第二个嵌套for循环内只执行了一行代码，所以其执行次数为n²,那么main方法总执行次数为n+n²+n²=2n²+n。根据大o推导规则，去掉n保留最高阶项，并去掉最高阶项的常数因子2，所以最终main方法的时间复杂度为O(n²)

1.1.2.4最坏情况

从心理学角度讲，每个人对发生的事情都会有一个预期，比如看到半杯水，有人会说:哇哦，还有半杯水哦!但也有人会说∶天哪，只有半杯水了。一般人处于一种对未来失败的担忧，而在预期的时候趋向做最坏的打算，这样即使最糟糕的结果出现，当事人也有了心理准备，比较容易接受结果。假如最糟糕的结果并没有出现，当事人会很快乐。

算法分析也是类似，假如有一个需求:
有一个存储了n个随机数字的数组，请从中查找出指定的数字。

public int search(int num){
	int[]arr={11,10,8,9,7,22,23,0};
	for (int i = o; i < arr.length; i++) {
		if (num==arr[i]){
		return i;
		}
	}
	return -1;
}

• 最好情况∶
  查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)

• 最坏情况∶
  查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)

• 平均情况∶
  任何数字查找的平均成本是O(n/2)

最坏情况是一种保证，在应用中，这是一种最基本的保障，即使在最坏情况下，也能够正常提供服务，所以，除非特别指定，我们提到的运行时间都指的是最坏情况下的运行时间。

1.2 算法的空间复杂度分析。

计算机的软硬件都经历了一个比较漫长的演变史，作为为运算提供环境的内存，更是如此，从早些时候的512k经历了1M，2.M，4M…等，发展到现在的8G，甚至16G和32G，所以早期，算法在运行过程中对内存的占用情况也是一个经常需要考虑的问题。我么可以用算法的空间复杂度来描述算法对内存的占用。

1.2.1 java中常见内存占用

1. 基本数据类型内存占用情况∶
   
2. 计算机访问内存的方式都是一次一个字节
   
3. 3.—个引用(机器地址）需要8个字节表示:
   例如:Date date = new Date().则date这个变量需要占用8个字节来表示
4. 创建一个对象，比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。

5.—般内存的使用，如果不够8个字节，都会被自动填充为8字节:

6. java中数组被被限定为对象，需要24字节的头信息。
   他们一般都会因为记录长度而需要额外的内存，一个原始数据类型的数组一般需要24字节的头信息（16个自己的对象开销，4字节用于保存长度以及4个填充字节）再加上保存值所需的内存。

1.2.2算法的空间复杂度

了解了java的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。
算法的空间复杂度计算公式记作:S(n)=O(f(n)),其中n为输入规模，f(n)为语句关于n所占存储空间的函数。

案例:
  对指定的数组元素进行反转，并返回反转的内容。
解法一:

public static int[]reverse1int[]arr){
	int n=arr.length;//申请4个字节
	int temp;/1/申请4个字节
	for(int start=,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; i >=0; i--) {
		temp[n-1-i]=arr[i];
	}
	return temp;
}

忽略判断条件占用的内存，我们得出的内存占用情况如下:

• 算法—∶
  不管传入的数组大小为多少，始终额外申请4+4=8个字节;
• 算法二:
  4+4n+24=4n+28;

  根据大O推导法则，算法一的空间复杂度为O(1),算法二的空间复杂度为o(n)所以从空间占用的角度讲，算法一要优于算法二。由于java中有内存垃圾回收机制，并且jym对程序的内存占用也有优化（例如即时编译），我们无法精确的评估一个java程序的内存占用情况，但是了解了java的基本内存占用，使我们可以对java程序的内存占用情况进行估算。
  由于现在的计算机设备内存一般都比较大，基本上个人计算机都是4G起步，大的可以达到32G，所以内存占用一般情况下并不是我们算法的瓶颈，普通情况下直接说复杂度，默认为算法的时间复杂度。

  但是，如果你做的程序是嵌入式开发，尤其是一些专感器设备上的内置程序，由于这些设备的内存很小，一般为几kb，这个时候对算法的空间复杂度就有要求了，但是一般做java开发的，基本上都是服务器开发，一般不存在这样的问题。