1-1 线性查找的实现与迭代

【实现1】

优化

• 把构造器私有，让外部无法实例化类的对象

• 写了static后， 用户在使用 search 方法时可以直接用类名.方法的方式调用，不用实例化一个对象。

public class LinearSearch {
    //把构造器私有，让外部无法实例化类的对象
    private LinearSearch(){}

    //写了static后， 用户在使用 search 方法时可以直接用 类名.方法的方式调用，不用实例化一个对象。
    public static int search(int [] data, int target){
        for (int i = 0; i < data.length; i++) {
            if(data[i] == target){
                return i;
            }
        }
        return -1;
    }

    @Test
    public void test(){
        int[] data = {24,18,12,9,16,66,32,4};

        int result = LinearSearch.search(data,24);
        System.out.println(result);
    }
}

【实现2】

问题

• 1、用户查找的数据不可能只是 int 型，重载很多针对不同类型的方法
• 2、泛型容纳的只能是类对象，不能是基本数据类型
• 3、 == 只能用于数值判断，无法用于类对象的判断

优化

• 1、使用泛型
• 2、使用包装类
• 3、使用equals()方法，注意：用 arr.target (防止空指针)
• 3-2、要求传入的自定义类重写equals()方法

public static <E> int search(E [] data, E target){
        for (int i = 0; i < data.length; i++) {
            if(data[i].equals(target)){
                return i;
            }
        }
        return -1;
    }

验证时间复杂度 O(n)

public static void main(String[] args) {
        int [] dataSize = {1000000,10000000};
        for(int n:dataSize){
            Integer[] data = ArrayGenerator.generateOrderedArray(n);
            long start = System.nanoTime();//纳秒
            for (int i = 0;i < 100; i++) {
                LinearSearch.search(data,n);
            }
            long end = System.nanoTime();
            double time = (end-start)/1000000000.0;
            System.out.println("n = "+ n + ",100 runs " + time + "s");
        }
    }

结果

n = 1000000,100 runs 0.1199648s
n = 10000000,100 runs 1.2683603s