数据结构与算法实战（一）线性查找

数据结构与算法实战（一）线性查找

一、算法引入

在一堆试卷中，找到属于自己的试卷，需要一张一张的查看，第一张：不是，第二张：不是，… 第十张：是，找到了

算法输入：数组（或其他数据结构）和目标元素

算法输出：目标元素所在索引；若不存在，则返回-1

二、代码实现

public class LinearSearch {
    
    private LinearSearch(){} //构造函数私有化，无法new一个对象

    public static int search(int[] data, int target) {

        for (int i = 0; i < data.length; i++) {
            if (data[i] == target)
                return i;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] data = {20,10,25,16,8};
        int res = LinearSearch.search(data, 16);
        System.out.println(res);//3

        int res2 = LinearSearch.search(data, 1);
        System.out.println(res2);//-1
        
    }
}

三、代码改进（使用泛型）

使用泛型要求:

1. 不可以是基本数据类型，只能是类对象

   基本数据类型为：boolean,byte,short,int ,float,double,long,char

2. 每个基本数据类型都有对应包装类

   包装类：Boolean，Byte,Short,Integer,Float,Double,Long,Character

//使用泛型改进代码

public class LinearSearch {

    private LinearSearch(){} //构造函数私有化，无法new一个对象

    public static <E> int search(E[] data, E target) {

        for (int i = 0; i < data.length; i++) {
            //对类对象之间的判等，要使用equals方法
            if (data[i].equals(target))
                return i;
        }
        return -1;
    }

    public static void main(String[] args) {

        Integer[] data = {20,10,25,16,8};

        int res = LinearSearch.<Integer>search(data, 16);//Java 8之后可以不用这样写
        System.out.println(res);//3

        int res2 = LinearSearch.search(data, 1);
        System.out.println(res2);//-1

    }
}

四、使用自定义类测试算法

自定义Student类，并重写equals方法（如使用默认equals方法不可以比较自定义类型对象）

public class Student {

    private String name;

    public Student(String name){
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {

        if(this == obj)
            return true;
        if(obj == null)
            return false;
        if(this.getClass() != obj.getClass())
            return false;

        Student student = (Student)obj;
        return this.name.equals(student.name);
    }
}

测试：

Student[] students = {new Student("Sum"),
                      new Student("ycj"),
                      new Student("Simone")};
Student ycj = new Student("ycj");
int res3 = LinearSearch.search(students,ycj);
System.out.println(res3); //1

五、循环不变量

每一轮循环开始的时候，算法都满足的性质（某一条件是不变的）

例如：线性查找中每一轮循环开始之前都满足 data[0 … i) （左闭右开） 中没有找到目标

而循环体在做的事就是维持这个循环不变量（写for循环时要清楚循环体要干什么）

六、写出正确代码

• 定义清楚循环不变量
• 维护循环不变量
• 定义清楚函数的功能

七、复杂度分析

复杂度分析是为了表示算法的性能

通常看最差的情况，算法运行的上界

例如这段代码

通常用n代表数据的规模，例如此代码的n=data.length

O(n):表示整个算法性能和n成线性增长的关系

常数不重要

复杂度描述的是随着数据规模n的增大，算法性能的变化趋势

如果T=c1 * n+c2（c1，c2为常数），这样的算法它的时间复杂度就可以称为O(n)

如果T2 = 2n²（循环嵌套一次循环）则时间复杂度为O(n²)

八、常见算法复杂度

一定先要明确n是什么

规模为n的for循环： O(n)

一个数组中的元素可以组成哪些数据对:O(n²)

for (int i = 0; i <data.length ; i++) {
            for (int j = 0; j < data.length; j++) {
                //获取数据对（data[i],data[j]）
            }
        }

遍历一个n*n的二维数组 ：O(n²)

数字n的二进制位数：O(log n)

while (n){
    n%2 //n的二进制中的一位
    n /= 2
}

数字n的所有约数O(√n)

for (int i = 0; i*i <= n; i++) {
    if(n % i ==0)
        //i和 n/i 是n的两个约数
}

长度为n的二进制数字：O(2^n)

长度为n的数组所有排列 ：O(n!)

判断数字n是否是偶数 ：O(1)

return n%2 == 0

九、测试算法性能

int[] dataSize = {1000000,10000000};

    for(int n : dataSize){
        Integer[] data = ArrayGenerator.generateOrderedArray(n);

        long startTime = System.nanoTime();//纳秒
        for (int k = 0; k < 100; k++)
            LinearSearch.search(data,n);
        long endTime = System.nanoTime();
        System.out.println("运行100次总时间为"+ (endTime - startTime)/1000000000.0+"秒");
    }

}

运行百万级别和千万级别的结果，刚好约为10倍