本文详细介绍了线性查找算法的工作原理，包括其基本操作和时间复杂度O(n)的特点。讨论了数据量大和目标位置不确定性时的效率问题，并展示了如何使用泛型改进代码，以适应不同数据类型。同时，通过实例演示了如何在自定义对象数组中查找，以及对算法性能的复杂度分析和实测。
线性查找
线性查找是一种在数组中查找数据的算法, 即便数据没有按顺序存储，也可以应用线性查找。线性查找的操作很简单，只要在数组中从头开始依次往下查找即可。虽然存储的数据类型没有限制，但为了便于理解，这里我们假设存储的是整数
找到6了，查找结束。
线性查找需要从头开始不断地按顺序检查数据，因此在数据量大且目标数据靠后，
或者目标数据不存在时，比较的次数就会更多，也更为耗时。若数据量为 n，线性查找
的时间复杂度便为 O(n)。
public class LinearSearch {
// 构造函数 私有 不希望被 new
private LinearSearch(){
System.out.println("构造函数被调用");
}
/**
* @param data 目标数组
* @param target 目标值
* @return 返回 目标索引
*/
public static int search(int[] data, int target){
for (int i = 0; i < data.length; i++) {
if (data[i] == target)
return i;
}
return -1;
}
}
测试
package com.qcx.algo.linearSearch;
public class TestLinearSearch {
public static void main(String[] args) {
// 声明一个数组
int[] data = {24, 18, 12, 9, 16, 66, 32, 4};
// 编写算法， 在 data中查找值为 16的元素
int index = LinearSearch.search(data, 16);
System.out.println(index);
int index2 = LinearSearch.search(data, 666);
System.out.println(index2);
}
}
- 使用泛型修改代码这样对传入的数据不做具体限制
public class LinearSearch {
// 构造函数 私有 不希望被 new
private LinearSearch(){
System.out.println("构造函数被调用");
}
/**
* @param data 目标数组
* @param target 目标值
* @return 返回 目标索引
*/
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;
}
}
测试
public class TestLinearSearch {
public static void main(String[] args) {
// 声明一个数组
Integer[] data = {24, 18, 12, 9, 16, 66, 32, 4};
// 编写算法， 在 data中查找值为 16的元素
int index = LinearSearch.search(data, 16);
System.out.println(index);
String[] data2 = {"24", "haha", "12", "9", "hehe", "66", "32", "4"};
int index2 = LinearSearch.search(data2, "hehe");
int index3 = LinearSearch.search(data2, "huhu");
System.out.println(index2);
System.out.println(index3);
}
}
测试自定义类型的线性查找
定义Student类
import java.util.Objects;
// 像Student这种实体类， 我们一般设计成JavaBean
public class Student {
// 成员属性私有 (必须)
private String name;
// 无参构造(必须)
public Student() {
}
// 全参构造
public Student(String name) {
this.name = name;
}
// get/set 方法 (必须)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object student) {
if (this == student)
return true;
if (student == null)
return false;
if (this.getClass() != student.getClass())
return false;
Student anothor = (Student)student;
return this.name.equals(anothor.name);
// String targetName = anothor.name;
// boolean b = this.name.equals(targetName);
// return b ;
}
}
进行测试
package com.qcx.algo.defclass;
public class LinearSearch {
// 构造函数 私有 不希望被 new
private LinearSearch(){
System.out.println("构造函数被调用");
}
/**
* @param data 目标数组
* @param target 目标值
* @return 返回 目标索引
*/
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;
}
public static void main(String[] args) {
Student[] students = {new Student("Eric"),
new Student("haha"),
new Student("James")};
Student target = new Student("James");
int index = LinearSearch.search(students, target);
System.out.println(index);
}
}
返回是2 , String 的equals方法值得我们学习
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
复杂度分析
表示算法的性能
常见算法复杂度分析
- 线性查找法 —> O (n)
- 一个数组中元素可以组成那些数据对 —> O (n^2)
- 遍历二维数组 —> O (n^2)
- log(n)
举例： 二分搜索
在最好情况下二分搜索的时间复杂度是 O(1)，最坏情况（平均情况）下 O(log n)，我们直接来看最坏情况下的例子。已知有 16 个元素的有序数组。
举个最坏情况的例子，比如我们要找的是数字 13。
选中间的元素作为中心点（长度的一半）
13 小于中心点，所以不用考虑数组的后一半
重复这个过程，每次都寻找子数组的中间元素
每次和中间元素比较都会使搜索范围减半。
所以为了从 16 个元素中找到目标元素，我们需要把数组平均分割 4 次，也就是说，
- 数字n的二进制数是多少 ----》O(log n)
package com.qcx.algo.defclass;
import java.util.ArrayList;
public class Jinzhi {
public static void main(String[] args) {
DToB(10);
DToB(8);
}
public static void DToB(int n){
int t = 0; // 用来记录位数
int bin = 0; // 用来记录最后的二进制数
int r = 0; // 余数
while (n !=0){
r = n%2;
n = n/2;
bin += r*Math.pow(10, t);
t++;
}
System.out.println(bin);
}
}
-
求约数 — 》O (n)
-
O 根号 n
-
长度为 n的二进制数字 O（2^n）
-
长度为 n的数组的所有排列 O（n!）
-
判断数字是否为偶数 O(1)
复杂度计较
O(1) < O(logn) < O(根号n) < O(n) < O(nlogn)< O(n^2) < O(2^n) < O(n!)
空间复杂度和时间复杂度同理
测试算法性能
生成数字工具类
package com.qcx.algo.testalgo;
public class ArrayGenerator {
private ArrayGenerator(){};
public static Integer[] generateOrderedArray(int n){
Integer[] arr = new Integer[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
return arr;
}
}
测试
package com.qcx.algo.testalgo;
public class LinearSearch {
// 构造函数 私有 不希望被 new
private LinearSearch(){
System.out.println("构造函数被调用");
}
/**
* @param data 目标数组
* @param target 目标值
* @return 返回 目标索引
*/
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;
}
public static void main(String[] args) {
int n = 10000;
Integer[] data = ArrayGenerator.generateOrderedArray(n);
long start = System.currentTimeMillis();
// System.out.println(start);
for (int i = 0; i < 100; i++) {
LinearSearch.search(data, n);
}
long end = System.currentTimeMillis();
System.out.println(end-start);
}
}
扫一扫
385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
