一、时间复杂度

1、取决因素

在计算机编写程序前，依据统计方法进行估算，一个高级程序语言编写的计算机程序在计算机上运行消耗的时间取决于下列因素：

  1. 算法采用的策略和方案；
  2. 编译产生的代码质量；
  3. 问题的输入规模(所谓的问题输入规模就是输入量的多少)；
  4. 机器执行指令的速度；
    抛开与计算机本身的因素不谈，一个程序的运行时间就取决于算法的好坏和问题的输入规模。
注：如果算法固定，那么运行时间就只与问题的输入规模有关。

2、求1到100的和

//方法一：

	int sum = 0;	//执行1次
	int n= 100;	//执行1次
	for(int i = 1; i <= n; i++){	//执行n+1次
		sum += i;	//执行n次
	}
//方法二：

	int sum = 0;	//执行1次
	int n = 100;	//执行1次
	sum = (n+1)*n/2;	//执行一次

可以很明显的看出，采用不同的算法，程序所执行的时间是不同的，所以算法的优劣是非常重要的。

3、大O表示法

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

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

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

大O阶的表示法有以下几个规则可以使用：

  • 用常数1取代运行时间中的所有加法常数；
  • 在修改后的运行次数中，只保留高阶项；
  • 如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数；
常数因子：一个不随自变化而变化的一个因子。
当然，这个理解是非常抽象的。
简单来说，比如3n，不管你输入的n是几，时间开销并不会随数据规模增长而增长。
	x=n+3与x=2*n+3
这里的 n ,2n 就是常数因子，与这个项相乘的常数就分别为1和2

4、大O举例

大O记法的几个规则初看确实无法理解，看下边几个例子就可以很快理解了。

//算法一
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);
}

如果忽略判断条件的执行次数和输出语句的执行次数，那么当输入规模为n时，以上算法执行的次数分别为：
算法一：3次
算法二：n+3次
算法三：n^2+2次

所以，上述算法的大O记法分别为：
算法一：O(1)
算法二：O(n)
算法三：O(n^2)

5、常见的大O阶

5.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次.

5.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++) {
			sum+=i;
		}
	}
	System.out.println(sum);
}

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

5.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);
}
5.4 对数阶
int i=1,n=100;
	while(i<n){
		i = i*2;
	}

由于每次i*2之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到x=log(2)n,所以这个循环的时间复杂度为 O(logn);
对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以我们会忽略底数。

5.5 常数阶

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

public static void main(String[] args) {
	int n=100;
	int i=n+2;
	System.out.println(i);
}

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

6、常见时间复杂度总结

描述

增长量级

说明

举例

常数级别

1

普通语句

将两个数相加

对数级别

logN

二分策略

二分查找

线性级别

N

循环

找出最大元素

线型对数级别

NlogN

分治思想

归并排序

平方级别

N^2

双层循环

检查所有元素对

立方级别

N^3

三层循环

检查所有三元组

指数级别

2^N

穷举查找

检查所有子集

复杂程度从低到高依次为：
O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)< O(n ^3)

二、空间复杂度

空间复杂度用来描述算法对内存的占用。

1、java中常见内存占用

数据类型 内存占用字节数

数据类型

内存占用字节数

byte

1

short

2

int

4

long

8

float

4

double

8

boolean

1

char

2

2、注意点

  1. 计算机访问内存的方式都是一次一个字节
  2. 一个引用（机器地址）需要8个字节表示：例如： Date date = new Date(),则date这个变量需要占用8个字节来表示
  3. 创建一个对象，比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。
  4. 一般内存的使用，如果不够8个字节，都会被自动填充为8字节
  5. java中数组被被限定为对象，他们一般都会因为记录长度而需要额外的内存，一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)再加上保存值所需的内存。

3、算法的空间复杂度

算法的空间复杂度计算公式记作：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开发的，基本上都是服务器开发，一般不存在这样的问题。