复杂度是评价一个程序（算法）好坏的标准。我们可以从两个维度来评价程序的好坏，其一是程序的运行速度（时间复杂度）；其二是程序所占用的内存空间（空间复杂度）。
一、时间复杂度
时间复杂度是指完成一个算法所需的时间。在给定CPU的前提下，单位时间内执行语句的条数是基本恒定的，这时，衡量算法的运行时间也就是衡量算法的指令执行个数。Java中的基本指令（O（1））可以看作指令的替代。
在算法固定的前提下，随着算法处理数据规模的不同，算法需要的语句数也不同，这时就需要得到一个语句数关于数据规模的函数关系来大致估算该算法的时间复杂度。
例1：void func1(int N){
int count = 0 ;
for ( int i = 0 ; i < N ; i ++ ) {
for ( int j = 0 ; j < N ; j ++ ) {
count ++ ;
}
}
for ( int k = 0 ; k < 2 * N ; k ++ ) {
count ++ ;
}
int M = 10 ;
while (( M -- ) > 0 ) {
count ++ ;
}
在func1中，指令个数为n*n+2*n+10；
例2： void func2 ( int N ) {
int count = 0 ;
for ( int k = 0 ; k < 2 * N ; k ++ ) {
count ++ ;
}
int M = 10 ;
while (( M -- ) > 0 ) {
count ++ ;
}
System . out . println ( count );
}
在func2中，指令个数为2*n+10；
在上面两个例子中，我们可以得到以上关系式。在表示时间复杂度时，采用大O（）渐进表示。它满足下面的规则：
（1）只保留函数关系中的最高次项，也就是将func1的时间复杂度表示为O（n*n）；
（2）将保留项的常数系数化为1，也就是将func2的时间复杂度表示为O（n）。
例3：冒泡排序 O（n^2）
在下面的程序中，如果将生成数组的个数改成80000，运行时间大概就是生成40000个数的四倍。
数组里元素个数为40000的实际运行时间（在1.6GHz的计算机上运行）：2.562s；80000个数的实际运行时间是10.572s。
public class SortDemo {
public static void sort(long[] array){
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - i - 1; j++) {
if(array[j] > array[j + 1]){
long t = array[j];
array[j] = array[j + 1];
array[j + 1] = t;
}
}
}
}
private static Random random = new Random();
public static long[] 生成一个乱序随机数组(int n){
long[] array = new long[n];
for (int i = 0; i < n; i++) {
array[i] = random.nextInt(2 * n);
}
return array;
}
public static void main(String[] args) {
long[] a1 = 生成一个乱序随机数组(40000);
long b = System.currentTimeMillis();
sort(a1);
long e = System.currentTimeMillis();
long ms = e - b;
double s = ms / 1000.0;
System.out.println(s);
}
}
例4：O（n^3）
例5：二分查找 O（log（n））
算法时间复杂度的排序：
O(1)常数阶 < O(logn)对数阶 < O(n)线性阶 < O(n^2)平方阶 < O(n^3)(立方阶) < O(2^n) (指数阶)
二、空间复杂度
空间复杂度粗略的认为是内存消耗的大小和数据规模的关系，是对一个算法在运行过程中临时占用存储空间大小的量度。在计算空间复杂度时，算法输入参数占用的空间不计算在空间复杂度内，比如：数组占用的空间不算；
| 冒泡排序 | 斐波那契数列 | 汉诺塔 | |
| 空间复杂度 | O(1) | O（n） | O（n） |
