Java数据结构（二）算法分析

1.1、算法的时间复杂度分析

1）函数渐近增长

• 概念： 给定两个函数f(n)和g(n)，如果存在一个整数N，使得对于所有的n>N，f(n)总是比g(n)大，那么我们说f(n)的增长渐近快 于g(n)
• 规则
  1. 算法函数中的 常数 可以忽略
  2. 算法函数中 最高次幂的常数因子 可以忽略
  3. 算法函数中 最高次幂越小，算法 效率越高

2）算法时间复杂度

1、大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)增长最慢的算法为最优算法

---

实例

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

所以，上述算法的大O记法分别为：

• 算法一：O(1)
• 算法二：O(n)
• 算法三：O(n^2)

2、常见的大O阶

线性阶 O(n)

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

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

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^2)

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

下面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环中出来，就需要执行100*100次，也就是n的平方次，所以这段代码 的时间复杂度是 O(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++) {
            sum+=i;
        }
    }
    System.out.println(sum);
}

立方阶 O(n^3)

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

下面这段代码，n=100，也就是说，外层循环每执行一次，中间循环循环就执行100次，中间循环每执行一次，最内层循环需要执行100次，那总共程序想要从这三个循环中出来，就需要执行100100100次，也就是n的立方，所以这段代码的时间复杂度是 O(n^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);
}

对数阶 O(logn)

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的增大，不管底数为多少， 他们的增长趋势是一样的，所以我们会忽略底数

常数阶 O(1)

一般 不涉及循环操作 的都是常数阶，因为它不会随着n的增长而 增加操作次数。例如： 下述代码，不管输入规模n是多少，都执行2次，根据大O推导法 则，常数用1来替换，所以上述代码的时间复杂度为 O(1)

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

常见时间复杂度总结

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

3）函数调用的时间复杂度分析

案例：

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循环内只执行了一行代码，所以其执行次数为 n^2，那么main方法总执行次数为 n+n2+n2 = 2n^2+n。根据大O推导规则，去掉n保留最高阶项，并去掉最高阶项的常数因子2，所以最终main方法的时间复杂度为 O(n^2)

4）最坏情况

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

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

1）java中常见内存占用

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

数据类型	描述	占用字节	取值范围	默认值
byte	Java中最小的数据类型	1个字节	-128~127	0
short	短整型	2个字节	-32768~32717	0
int	整型，用于存储整数	4个字节	-2147483648~2147483647	0
long	长整型	8个字节	-263~263-1	0L
float	单精度浮点型，用于存储带小数点的数字	4个字节	/	0.0f
double	双精度浮点型 用于存储带有小数点的数字	8个字节	/	0.0d
char	字符型，用于存储单个字符	2个字节	0~65535	空
boolean	布尔类型，用于判断真或假	1/8字节 (1位)	仅有两个值，即true、false	false

注：一个字节（byte）等于8位（bit）

• 计算机访问内存的方式都是 一次一个字节

• 一个变量引用（机器地址）需要 8个字节 表示

  例如： Date date = new Date()，则date这个变量需要占用8个字节来表示

• 创建一个对象
  比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，
  每个对象的 自身开销是 16个字节，用来保存对象的头信息

• 一般内存的使用，如果不够8个字节，都会被 自动填充为8字节

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

2）算法的空间复杂度

了解了java的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。

算法的空间复杂度计算公式记作：S(n) = O(f(n))，其中n为输入规模，f(n)为语句关于n所占存储空间的函数

由于java中有内存垃圾回收机制，并且jvm对程序的内存占用也有优化（例如即时编译），我们无法精确的评估一个java程序的内存占用情况，但是了解了java的基本内存占用，使我们可以对java程序的内存占用情况进行估算。
由于现在的计算机设备内存一般都比较大，基本上个人计算机都是4G起步，大的可以达到32G，所以内存占用一般情况下并不是我们算法的瓶颈，普通情况下直接说复杂度，默认为算法的时间复杂度。但是，如果是嵌入式开发，尤其是一些传感器设备上的内置程序，由于这些设备的内存很小，一般为几kb，这个时候对算法的空间复杂度就有要求了，但是一般做java开发的，基本上都是服务器开发，一般不存在这样的问题