Java中常用的4种查找算法详解

4种常用的查找算法

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

1.顺序（线性）查找

• 逐一比对，发现相同值时返回下标

package com.data.struct.search.lineSearch;

/**
 * @author Creepin
 * @date 2019/12/5 13:04
 * @description  线性查找：逐一比对，发现相同值时返回下标
 */
public class LineSearch {
    public static void main(String[] args) {
        int arr[] ={1,2,4,5,6,7,8};
        int index = lineSearch(arr, 2);
        if (index==-1){
            System.out.println("没找到指定元素");
        }else {
            System.out.println("找到指定元素下标为："+index);
        }
    }
    private static int lineSearch(int[] arr,int value){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==value){
                return i;
            }
        }
        return -1;
    }
}

2.二分查找/折半查找

• 要求待查找的数组必须有序

package com.data.struct.search.binary;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Creepin
 * @date 2019/12/5 13:36
 * @description
 * 二分查找 要求数组必须有序(借助集合优化查找结果)
 */
public class BinarySearch {
    public static void main(String[] args) {
        //测试1-100个数据的插值查找结果
        int[] arr = new int[100];
        for (int i=1;i<=100;i++){
            arr[i-1]=i;
        }
        List list = binarySearch(arr, 0, arr.length-1, 100);
        System.out.println("找到的下标索引为："+list);
    }
    private static ArrayList<Integer> binarySearch(int[] arr,int left,int right,int findVal){
        if (left>right){
            return new ArrayList<>();
        }
        int mid = (left+right) / 2;
        //找到中间值
        int midVal=arr[mid];
        if (findVal>midVal){
            //向右递归(有返回值的递归 需要使用return)
            return binarySearch(arr,mid+1,right,findVal);
        }else if (findVal<midVal){
            //向左递归
            return binarySearch(arr,left,mid-1,findVal);
        }else {
            //找到了()
            //避免一个数组中出现多个相同的值，用list存放所有满足条件的下标
            ArrayList<Integer> list = new ArrayList<>();
            //找到mid后分别向mid的前后进行扫描
            int tempIndex = mid -1;
            while (true){
                if (tempIndex<0||arr[tempIndex]!=findVal){
                    break;
                }
                list.add(tempIndex);
                tempIndex--;
            }
            list.add(mid);
            tempIndex = mid+1;
            while (true){
                if (tempIndex>arr.length-1||arr[tempIndex]!=findVal){
                    break;
                }
                list.add(tempIndex);
                tempIndex++;
            }
            return list;
        }
    }
}

3.插值查找

• 1.与二分查找类似，mid的计算方式不一样
• 2.对于分布不均匀的数据，插值查找不一定比二分查找快

package com.data.struct.search.insert;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Creepin
 * @date 2019/12/5 13:36
 * @description  批量替换变量名 shift+F6
 * 插值查找：1.与二分查找类似，mid的计算方式不一样
 *          2.对于分布不均匀的数据，插值查找不一定比二分查找快
 */
public class InsertValueSearch {
    public static void main(String[] args) {
        //测试1-100个数据的插值查找结果
        int[] arr = new int[100];
        for (int i=1;i<=100;i++){
            arr[i-1]=i;
        }
        List list = insertValueSearch(arr, 0, arr.length-1, 2);
        System.out.println("找到的下标索引为："+list);
    }
    private static ArrayList<Integer> insertValueSearch(int[] arr, int left, int right, int findVal){
        //插值查找要防止索引越界，查找值参与运算，mid的计算结果存在不确定性，需要提前判断
        if (left>right||findVal<arr[0]||findVal>arr[arr.length-1]){
            return new ArrayList<>();
        }
        int mid = left + (right - left) * (findVal - arr[left]) / (arr[right]-arr[left]);
        //找到中间值
        int midVal=arr[mid];
        if (findVal>midVal){
            //向右递归(有返回值的递归 需要使用return)
            return insertValueSearch(arr,mid+1,right,findVal);
        }else if (findVal<midVal){
            //向左递归
            return insertValueSearch(arr,left,mid-1,findVal);
        }else {
            //找到了()
            //避免一个数组中出现多个相同的值，用list存放所有满足条件的下标
            ArrayList<Integer> list = new ArrayList<>();
            //找到mid后分别向mid的前后进行扫描
            int tempIndex = mid -1;
            while (true){
                if (tempIndex<0||arr[tempIndex]!=findVal){
                    break;
                }
                list.add(tempIndex);
                tempIndex--;
            }
            list.add(mid);
            tempIndex = mid+1;
            while (true){
                if (tempIndex>arr.length-1||arr[tempIndex]!=findVal){
                    break;
                }
                list.add(tempIndex);
                tempIndex++;
            }
            return list;
        }
    }
}

4.斐波那契查找

package com.data.struct.search.fibonacci;

import java.util.Arrays;

/**
 * @author Creepin
 * @date 2019/12/6 14:13
 * @description 斐波那契排序算法:前提：有序数组
 */
public class FibonaciSort {
    //定义斐波那契数列的最大长度
    private static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1,3,4,5,10,15,34};
        int val = fibSort(arr, 34);
        System.out.println("找到了：index="+val);
    }
    //构建一个斐波那契数列
    private 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;
    }

    /**
     * 斐波那契排序
     * @param arr
     * @return
     */
    private static int fibSort(int[] arr,int findVal){
        int left = 0;
        int right = arr.length-1;
        int mid = 0;
        int k = 0;
        //mid = left + F(k-1) -1
        int[] fb = fib();
        //fb[k]-1是因为right是数组的下标索引  不是数组长度  （right = length -1）
        while (right>fb[k]-1){
            k++;
        }
        //因为arr数组的长度不一定等于f(k),所以利用中间数组 长度为f(k)
        //int[] temp = new int[fb[k]];
        int[] temp = Arrays.copyOf(arr, fb[k]);
        //将temp数组中多于arr数组的索引部分补齐
        for (int i=right+1;i<temp.length;i++){
            temp[i] = arr[right];
        }
        //遍历temp数组比较mid的值
        while (left<=right){
            mid = left + fb[k-1] -1;
            int midVal = temp[mid];
            if (findVal<midVal){
                right = mid -1;
                //此时需要向左递归，f[k] = f[k-1]+f[k-2]
                //前面还剩下f[k-1]个数
                k-=1;
            }else if (findVal>midVal){
                left = mid +1;
                k-=2;
            }else {
                //因斐波那契数列的值可能大于数组长度，
                //当匹配到的mid值大于right时，mid取right
                if (mid<=right){
                    //找到
                    return mid;
                }else {
                    return right;
                }
            }
        }
        return -1;
    }
}