查找算法简述及基本运用

在Java学习过程中，我们经常会运用到四种查询算法：

1. 顺序查找
2. 二分/折半查找
3. 插值查找
4. 斐波那契查找

现在笔者将会对这四种算法进行简单叙述。

一、线性查找算法

基本思路：逐一比对，发现有相同值，就返回下标。
适用范围：有序数组+无序数组

代码示例：

public class SeqSearch {
    public static void main(String[] args) {
        int arr[] = {1,2,5,6,8,4,3};
        int index = seqSearch(arr,2);
        if(index == -1) System.out.println("没有找到");
        else System.out.println("找到了，下标为："+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.将目标值与array[mid]对比
2.1 目标值>array[mid] 说明需要查找的数在mid右边，向右递归查找
2.2 目标值 2.3 目标值 == array[mid] 找到 返回下标

结束条件：1.找到了 2.left>right

适用范围：有序数组

代码示例：

   //基本二分查找
    public static int binarySearch(int[] array,int left,int right,int aimValue){
            if(left>right) return -1;
            int mid = (left+right)/2;
            int minValue = array[mid];
            if(aimValue > minValue) return binarySearch(array,mid+1,right,aimValue);
            else if(aimValue < minValue) return binarySearch(array,left,mid-1,aimValue);
            else return mid;
    }

 //二分查找功能完善
 //对于多个相同数值，将所有值都查到
  //思路分析：
  //  1.在找到mid索引值，不要马上返回,加入集合ArrayList
  //  2.向mid索引值的左边扫描，将所有满足值的元素的下标，加入到集合ArrayList
  //  3.向mid索引值的右边扫描，将所有满足值的元素的下标，加入到集合ArrayList
  //  4.返回 ArrayList
    public static List<Integer> binarySearch2(int[] array, int left, int right, int aimValue){
        if(left>right) return new ArrayList<>();
        int mid = (left+right)/2;
        int minValue = array[mid];
        if(aimValue > minValue) return binarySearch2(array,mid+1,right,aimValue);
        else if(aimValue < minValue) return binarySearch2(array,left,mid-1,aimValue);
        else{
            List<Integer> resList = new ArrayList<>();
            resList.add(mid);
            int temp = mid -1;
            while(true){
                if(temp<0||array[temp]!=aimValue) break;
                resList.add(temp);
                temp-=1;
            }
            temp = mid+1;
            while(true){
                if(temp>array.length-1||array[temp]!=aimValue) break;
                resList.add(temp);
                temp+=1;
            }
            return resList;
        }
    }

三、插值查找算法

基本思路：

适用范围：有序数列

举例说明：

代码示例：

public class InsertSearchTest {

    static int[] array = {1,2,3,45,55,78,112,124,156,178};

    public static void main(String[] args) {
        System.out.println(insertSearch(array,0,array.length-1,156));
    }

    /**
     * 插值查找 公式  mid = left + (right-left)*(aimValue-array[left])/(array[right]-array[left]) 自适应
     * @param array
     * @param left
     * @param right
     * @param aimValue
     * @return
     */
    public static int insertSearch(int[] array,int left,int right,int aimValue){
        if(left>right||array[0]>aimValue||array[array.length-1]<aimValue) return -1;
        int mid = left + (right-left)*(aimValue-array[left])/(array[right]-array[left]);
        int minValue = array[mid];
        if(aimValue > minValue) return insertSearch(array,mid+1,right,aimValue);
        else if(aimValue < minValue) return insertSearch(array,left,mid-1,aimValue);
        else return mid;
    }
}

注意事项：
1.对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快。
2.关键字分布不均匀的情况下，该方法不一定比折半查找要好。
— 尚硅谷Java数据结构和算法

三、斐波那契（黄金分割法）查找算法

基本原理：



代码示例：

public class FibonacciSearch {
    static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1,8,10,89,1000,1234};
        System.out.println(fibSearch(arr,10));
    }

    //获取斐波那契数列
    public static  int[] fib(){
        int[] f = new int[maxSize];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            f[i] = f[i-1]+f[i-2];
        }
        return f;
    }

    //编写斐波那契查找算法
    //使用非递归的方式编写算法
    public static  int fibSearch(int[] a, int key){
        int low = 0;
        int high = a.length - 1;
        int k = 0;//表示斐波那契分割数值下标
        int mid = 0;//存放mid值
        int f[] = fib();
        //获取到斐波那契分割数值下标
        while(high>f[k]-1){
            k++;
        }
        //因为f[k]值可能会大于a的长度，因此我们需要使用Arrays类
        // 构造一个新的数组，并指向temp[]
        int[] temp = Arrays.copyOf(a,f[k]);
        for(int i = high+1;i<temp.length;i++){
            temp[i] = a[high];
        }
        while (low<=high){
            mid = low + f[k-1]-1;
            if(key<temp[mid]){
                high = mid - 1;
                k--;
            }else if(key>temp[mid]){
                low = mid + 1;
                k-=2;
            }else{
                if(mid <= high) return mid;
                else return high;
            }
        }
        return -1;
    }
}