Java实现线性查找法，并对进行性能检测

在静态型数据源中进行线性查找

package linearsearch;

/**
 * Wen(Joan) Zhao <withzhaowen@126.com>
 * 2021/8/29
 *
 * 线性查找法实现 在data数组中查找16
 *
 * input: 数组，和目标元素
 * output: 目标元素所在的索引；若不存在，返回-1
 */
public class LinearSearch {

    public static void main(String[] args) {
        int[] data = new int[]{24,18,12,9,16,66,32,4};
        int target = 16;

        int index = LinearSearch.lsearch(data,target);
        System.out.println(index);
    }

    /**
     * 线性查找算法 返回下标
     * @param target
     * @return
     */
    public static int lsearch(int[] data,int target){
        // 查找到指定的数字
        for(int i=0;i< data.length;i++){
            int temp = data[i];
            if(temp == target){ return i; }
        }

        return -1;
    }
}

在动态型数据源中进行线性查找

package linearsearch;

/**
 * Wen(Joan) Zhao <withzhaowen@126.com>
 * 2021/8/29
 *
 * 线性查找法实现 在data数组中查找16
 *
 * input: 数组，和目标元素
 * output: 目标元素所在的索引；若不存在，返回-1
 */
public class LinearSearch{

    public static void main(String[] args) {
        Integer[] data = new Integer[]{24,18,12,9,16,66,32,4};
        Integer target = 16;

        int index = LinearSearch.lsearch(data,target);
        System.out.println(index);
    }

    /**
     * 线性查找算法 返回下标
     * @param target
     * @return 将其改造为泛型方法  ，用户可以过根据自己的代码进行查找
     *
     * Java泛型：
     * 不可以使用基本数据类型，只能是类对象
     * <基本数据类型    ： boolean byte char short int long float double>
     * <基本类型的包装类： Boolean Byte Character Short Integer Long Float Double>
     */
    public static <E> int lsearch(E[] data,E target){
        // 查找到指定的数字
        for(int i=0;i< data.length;i++){
            // 判断两个类对象相等时 应该使用equal
            // 判断值相等使用 ==  (类对象使用只会比较引用地址)
            if(data[i].equals(target)){ return i; }
        }

        return -1;
    }
}

测试算法性能

1.创建一个数组生成器

package linearsearch;

/**
 * Wen(Joan) Zhao <withzhaowen@126.com>
 * 2021/8/29
 *
 * 数组生成器
 */
public class ArrayGenerator {
    private ArrayGenerator() {
    }

    public static Integer[] generateOrderedAarray(int n){
        Integer[] arr = new Integer[n];
        for(int i=0 ; i<n ; i++){
            arr[i] = i;
        }
        return arr;
    }
}

2.第一次测试

package linearsearch;

/**
 * Wen(Joan) Zhao <withzhaowen@126.com>
 * 2021/8/29
 *
 * 线性查找法实现 在data数组中查找16
 *
 * input: 数组，和目标元素
 * output: 目标元素所在的索引；若不存在，返回-1
 */
public class LinearSearch{

    public static void main(String[] args) {
        int index = LinearSearch.lsearch(student,sTest);
        System.out.println(index);*/

        Integer n = 10000000;
        Integer[] data = ArrayGenerator.generateOrderedAarray(n);

        long startTime = System.nanoTime();
        LinearSearch.lsearch(data,n);
        long endTime = System.nanoTime();

        double time = (endTime - startTime) / 1000000000.0;
        System.out.println(time+"s ");
    }

    /**
     * 线性查找算法 返回下标
     * @param target
     * @return 将其改造为泛型方法  ，用户可以过根据自己的代码进行查找
     *
     * Java泛型：
     * 不可以使用基本数据类型，只能是类对象
     * <基本数据类型    ： boolean byte char short int long float double>
     * <基本类型的包装类： Boolean Byte Character Short Integer Long Float Double>
     */
    public static <E> int lsearch(E[] data,E target){
        // 查找到指定的数字
        for(int i=0;i< data.length;i++){
            // 判断两个类对象相等时 应该使用equal
            // 判断值相等使用 ==  (类对象使用只会比较引用地址)
            if(data[i].equals(target)){ return i; }
        }

        return -1;
    }
}

0.0323209s 

3.第二次测试

package linearsearch;

/**
 * Wen(Joan) Zhao <withzhaowen@126.com>
 * 2021/8/29
 *
 * 线性查找法实现 在data数组中查找16
 *
 * input: 数组，和目标元素
 * output: 目标元素所在的索引；若不存在，返回-1
 */
public class LinearSearch{

    public static void main(String[] args) {
        Integer n = 10000000;
        Integer[] data = ArrayGenerator.generateOrderedAarray(n);

        long startTime = System.nanoTime();
        for(int k = 0;k<100;k++){
            LinearSearch.lsearch(data,n);
        }
        long endTime = System.nanoTime();

        double time = (endTime - startTime) / 1000000000.0;
        System.out.println("n="+n+" 100 runs : "+time+"s ");
    }

    /**
     * 线性查找算法 返回下标
     * @param target
     * @return 将其改造为泛型方法  ，用户可以过根据自己的代码进行查找
     *
     * Java泛型：
     * 不可以使用基本数据类型，只能是类对象
     * <基本数据类型    ： boolean byte char short int long float double>
     * <基本类型的包装类： Boolean Byte Character Short Integer Long Float Double>
     */
    public static <E> int lsearch(E[] data,E target){
        // 查找到指定的数字
        for(int i=0;i< data.length;i++){
            // 判断两个类对象相等时 应该使用equal
            // 判断值相等使用 ==  (类对象使用只会比较引用地址)
            if(data[i].equals(target)){ return i; }
        }

        return -1;
    }
}

n=10000000 100 runs : 2.5389971s 

4.第三次测试

package linearsearch;

/**
 * Wen(Joan) Zhao <withzhaowen@126.com>
 * 2021/8/29
 *
 * 线性查找法实现 在data数组中查找16
 *
 * input: 数组，和目标元素
 * output: 目标元素所在的索引；若不存在，返回-1
 */
public class LinearSearch{

    public static void main(String[] args) {
        int[] dataSize = {1000000,10000000};
        for(int n:dataSize){
            Integer[] data = ArrayGenerator.generateOrderedAarray(n);

            long startTime = System.nanoTime();
            for(int k = 0;k<100;k++){
                LinearSearch.lsearch(data,n);
            }
            long endTime = System.nanoTime();

            double time = (endTime - startTime) / 1000000000.0;
            System.out.println("n="+n+" 100 runs : "+time+"s ");
        }
    }

    /**
     * 线性查找算法 返回下标
     * @param target
     * @return 将其改造为泛型方法  ，用户可以过根据自己的代码进行查找
     *
     * Java泛型：
     * 不可以使用基本数据类型，只能是类对象
     * <基本数据类型    ： boolean byte char short int long float double>
     * <基本类型的包装类： Boolean Byte Character Short Integer Long Float Double>
     */
    public static <E> int lsearch(E[] data,E target){
        // 查找到指定的数字
        for(int i=0;i< data.length;i++){
            // 判断两个类对象相等时 应该使用equal
            // 判断值相等使用 ==  (类对象使用只会比较引用地址)
            if(data[i].equals(target)){ return i; }
        }

        return -1;
    }
}

n=1000000 100 runs : 0.1400557s 
n=10000000 100 runs : 2.4041455s