12 数据结构与算法之查找算法

查找算法

Java 中，我们常用的查找有四种：

• 顺序 / 线性查找
• 二分查找 / 折半查找
• 插值查找
• 斐波那契查找

线性查找算法

按顺序与序列中的值一一比对即可。

代码实现：

package com.atguigu.search;

public class SeqSearch {
    public static void main(String[] args) {
        int[] arr = {1, 9, 11, -1, 34, 89};
        int value = 89;
        int index = seqSearch(arr, value);
        if(index == -1) {
            System.out.println("没有找到您想要的值");
        } else {
            System.out.printf("%d这个值在%d号位置", value, index);
        }
    }

    // 找到一个满足条件的值就返回。
    public static int seqSearch(int[] arr, int value) {
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] == value) {
                return i;
            }
        }
        return -1;
    }
}

二分查找

二分查找的序列必须是有序序列，每次可缩小一般范围，效率高。

思路分析：

1. 首先确定该数组的中间下标
   mid = (left + right) / 2

2. 然后让需要查找的数 finalVal 和 arr[mid] 比较
   如果finalVal > arr[mid] 则继续在数组的右边去找
   如果finalVal < arr[mid] 则继续在数组的左边去找
   如果finalVal = arr[mid] 找到了，停止查找

代码实现：

public static int binarySearch(int[] arr, int value) {
    int left = 0;
    int right = arr.length-1;
    while(left <= right) {
        int mid = (left + right) / 2;
        if(value > arr[mid]) {
            left = mid + 1;
        } else if(value < arr[mid]) {
            right = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
}

public static int binarySearch2(int[] arr, int left, int right, int value) {
    if(left > right) {
        return -1;
    } else {
        int mid = (left + right) / 2;
        if(value > arr[mid]) {
            return binarySearch2(arr, mid+1, right, value);
        } else if(value < arr[mid]) {
            return binarySearch2(arr, left, mid-1, value);
        } else {
            return mid;
        }
    }
}

插值查找：

插值查找原理介绍：

1. 插值查找算法类似于二分查找，不同的是插值每次从自适应 mid 处开始查找。
2. 更换折半查找的公式：
   
3. 基本思想是按比例确定 mid 的位置，也可以称为是自适应确定 mid 值。

代码实现：

public static int insertSearch(int[] arr, int key) {
    int left = 0;
    int right = arr.length - 1;
    while(left <= right && key <= arr[left] && key >= arr[right]) {  //限定key值，防止数组越界！！
        int mid = left + (right - left) * (key - arr[left]) / (arr[right] - arr[left]);
        if(arr[mid] > key) {
            right = mid - 1;
        } else if(arr[mid] < key) {
            left = mid + 1;
        } else {
            return mid;
        }
    }
    return -1;
}