一、前情回顾

👉传送门:1 详解线性查找法
👉传送门:2 线性查找的优化
👉传送门:3 线性查找的测试
👉传送门:4 循环不变量与复杂度分析
👉传送门:5 常见的时间复杂度

二、算法性能测试

Integer[] data = {24, 18, 12, 9, 16, 66, 32, 4};

我们对于之前的线性查找的算法，只是使用了一个含有8个元素的data数组进行测试，这个数组规模太小，在现代计算机上，对于 $O (n)$ 这个级别的复杂度，需要一定规模的数据才能看到相应的性能

1.生成测试用例

//作用：为我们生成一个数组，
public class ArrayGenerator {// 用户无需生成一个ArrayGenerator的对象，因此将构造函数设置为私有private ArrayGenerator(){}//使用静态方法//生成一个数组，数组中的元素是顺序存放public static Integer[] generateOrderedArray(int n){//对线性查找进行测试，所以生成的数组中的元素就是[0...n-1]//其中n的大小是变化的，是用户进行输入指定Integer[] arr = new Integer[n];for (int i = 0; i < n; i++) {arr[i] = i;}return arr;}
}

新建一个ArrayGenerator类，专门用于生成数组
数组生成中的方法采用静态方法，且用户无需生成一个ArrayGenerator的对象，因此将构造函数设置为私有
此处主要用于测试前面的线性查找算法的性能，所以生成的数组中的元素顺序存放，范围 $[0... n - 1]$ ，其中n是由用户进行指定的

2.使用测试用例

public class LinearSearchGenerator {private LinearSearchGenerator(){}public static <E> int search(E[] data, E target) {for (int i = 0; i < data.length; i++) {if (data[i] == target)return i;    //如果找到目标，返回对应的索引值}return -1;          //如果没有找到目标，返回-1}public static void main(String[] args) {//准备用于查找的数组，数组中有100000个元素Integer[] data = ArrayGenerator.generateOrderedArray(100000);int res = LinearSearchGenerator.search(data, 100000);System.out.println(res); //输出res}
}

data数组直接使用ArrayGenerator.generateOrderedArray()生成
首次传入的参数为100000，并且将查找的target值设为100000
很明显，在一个元素个数只有100000的数组中，且数组的元素是顺序存放的[0…100000)，查询是否有100000这个数的结果一定是-1

2.1 检验测试用例的用时

为了检验出对于这次查询，这次的函数调用具体消耗了多少时间，我们可以使用Java为我们提供的nanoTime()方法做一个计时

public class LinearSearchGenerator {private LinearSearchGenerator(){}public static <E> int search(E[] data, E target) {for (int i = 0; i < data.length; i++) {if (data[i] == target)return i;    //如果找到目标，返回对应的索引值}return -1;          //如果没有找到目标，返回-1}public static void main(String[] args) {int n = 100000;//准备用于查找的数组，数组中有100000个元素Integer[] data = ArrayGenerator.generateOrderedArray(n);//nanoTime()方法返回的其实是一个时间戳，// 是一个长整型，当前用纳秒计算的时间戳long startTime = System.nanoTime();int res = LinearSearchGenerator.search(data, n);System.out.println(res); //输出reslong endTime = System.nanoTime();//endTime - startTime的值就是两个时间戳之间的线性查找所用的时间，单位是纳秒//纳秒与秒之间是10^9//对于结果可以是一个浮点数，所以除以1000000000.0double time = (endTime - startTime) / 1000000000.0;System.out.println(time + " s");}
}

nanoTime()方法返回的其实是一个时间戳，用纳秒计算
在线性查找算法前使用一次，在线性查找算法结束后使用一次
endTime - startTime的值就是两个时间戳之间的线性查找所用的时间，单位是纳秒
结果如下：
- 消耗时间也与硬件有关，所以时间不一定相同

2.1 不同规模的测试用例的用时比较

public class LinearSearchGenerator {private LinearSearchGenerator() {}public static <E> int search(E[] data, E target) {for (int i = 0; i < data.length; i++) {if (data[i] == target)return i;    //如果找到目标，返回对应的索引值}return -1;          //如果没有找到目标，返回-1}public static void main(String[] args) {//不同规模的数据int[] dataSize = {1000000, 10000000};for (int n : dataSize) {//准备用于查找的数组Integer[] data = ArrayGenerator.generateOrderedArray(n);//nanoTime()方法返回的其实是一个时间戳，// 是一个长整型，当前用纳秒计算的话时间戳long startTime = System.nanoTime();//对于每个规模的数据，可以通过增加查找次数来达到扩大时间规模的目的/*因为直接进行查找特别大的规模的数据，比如1亿个数据，尤其我们需要的是连续空间，在一般的计算机上可能也会费一点劲，我们通过多做几回，对100万个数据进行100次查找，时间也会相对稳定一些*/for (int k = 0; k < 100; k++) {LinearSearchGenerator.search(data, n);}long endTime = System.nanoTime();//endTime - startTime的值就是两个时间戳之间的线性查找所用的时间，单位是纳秒//纳秒与秒之间是10^9//对于结果可以是一个浮点数，所以除以1000000000.0double time = (endTime - startTime) / 1000000000.0;System.out.println("n = " + n + ", 100runs: " + time + " s");}}
}

直接将不同规模的数据存放在数组中
- int[] dataSize = {1000000, 10000000};
对于每个规模的数据，可以通过增加查找次数来达到扩大时间规模的目的
- 因为直接进行查找特别大的规模的数据，比如1亿个数据，尤其我们需要的是连续空间，在一般的计算机上可能也会费一点劲，我们通过多做几回，对100万个数据进行100次查找，时间也会相对稳定一些
- 并且多次测量就有多组数据，可以进行统计分析，计算平均值、标准差等

for (int k = 0; k < 100; k++) {LinearSearchGenerator.search(data, n);
}

对于1000000和10000000这两个规模的数据，分别执行查找100次，最后的结果如下：
- 消耗时间也与硬件有关，所以每次时间都不相同
从运行结果中，可以看到，对于100万级别的数据，进行100次的查询，大概是0.13s的时间，对于1000万级别，大概是0.7s的时间
- 0.7大概是0.13的5倍(其实有时候是6倍以上甚至10倍，这与计算机的性能有关)，而我们第一次的数据规模是第二次的10倍
- 从侧面证明了线性查找法的时间复杂度是 $O (n)$ 级别的，时间性能和数据规模之间是线性关系
- 时间复杂度描述的是随着n的增长相应的算法的性能增长的趋势其实就是这个意思