二、算法分析

研究算法的最终目的就是如何花更少的时间，如何占用更少的内存去完成相同的需求，并且也通过案例演示了不同算法之间时间耗费和空间耗费上的差异，但我们并不能将时间占用和空间占用量化，有关算法时间耗费分析，称之为算法的时间复杂度分析，有关算法的空间耗费分析，称之为算法的空间复杂度分析。

2.1 算法时间复杂度分析

我们要计算算法时间耗费情况，首先我们得度量算法的执行时间，那么如何度量呢?

  • 事后分析估算方法︰
public static void main(String[] args){
    long start = System.currentTimeMills(); //获取开始时间
    int sum = 0;
    int n = 100;
    for(int i = 1; i <= n; i++){
        sum = sum + i;
    }
    System.out.println("sum"+sum);
    long end = System.currentTimeMills(); //获取结束时间
    System.out.println(end-start); // 运行时间
}

但是这种方法有很大的缺陷︰必须依据算法实现编制好的测试程序，通常要花费大量时间和精力，测试完了如果发现测试的是非常糟糕的算法，那么之前所做的事情就全部白费了，并且不同的测试环境(硬件环境)的差别导致测试的结果差异也很大。

  • 事前分析法：

在计算机程序编写前，依据统计方法对算法进行估算，经过总结，我们发现一个高级语言编写的程序程序在计算机上运行所消耗的时间取决于下列因素∶

1.算法采用的策略和方案;.

2.编译产生的代码质量;

3.问题的输入规模(所谓的问题输入规模就是输入量的多少);

4.机器执行指令的速度;

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

// 方法一
public static void main(String[] args){
    int sum = 0;
    int n = 100;
    for(int i = 1; i < n; i++){
        sum = sum + i;// 核心代码。 //执行n次
    }
    System.out.println("sum"+sum);
}

// 法方二
public static void main(String[] args){
    int sum = 0;  // 执行一次
    int n = 100;  // 执行一次
    sum = (n+1)*n/2; // 核心代码 // 执行一次
    System.out.println("sum"+sum);
}

我们分析一个算法的运行时间，最重要的就是把核心操作次数和输入规模关联起来。

在比较算法随着输入规模的增长量时，可以有以下规则︰

  1. 算法函数中的常数可以忽略;

  2. 算法函数中最高次幂的常数因子可以忽略;

  3. 算法函数中最高次幂越小，算法效率越高。

  • 大O记法

  1. 用常数1取代运行时间中的所有加法常数;

  2. 在修改后的运行次数中，只保留高阶项;

  3. 如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数;

他们的复杂程度从低到高依次为:
o(1)<O(logn)<Q(n)<O(nlogn)<O(n2)<O(n3)

2.2 算法的空间复杂度

2.2.1 Java中常见的内存占用

1.基本数据类型占用内存情况：

数据类型 内存占用字节数
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1
char 2
  1. 计算机访问内存的方式都是一次一个字节

1 B = 8 bit

  1. 一个引用（机器地址）需要8个字节表示∶例如:Date date = new Date(),则date这个变量需要占用8个字节来表示。
  2. 创建一个对象，比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。
  3. —般内存的使用，如果不够8个字节，都会被自动填充为8字节。
// 例
public class A {
    public int i = 1;
}
/*
	通过new A()创建一个对象的额内存如下：
		1. 整型成员变量a占用4个字节
		2. 对象本身占用16个字节
	那么创建该对象总共需要20个字节，但由于不是以8位为单位，会自动填充为24个字节。
*/
  1. Java 中数组被被限定为对象，他们一般都会因为记录长度而需要额外的内存，一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)再加上保存值所需的内存。

2.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;
}

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

算法一︰

不管传入的数组大小为多少，始终额外申请4+4=8个字节;

算法二∶

4+4n+24=4n+28;

根据大O推导法则，算法一的空间复杂度为O(1);,算法二的空间复杂度为O(n)所以从空间占用的角度讲，算法一要优于算法二。

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

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