java中的几种常用查找算法

①基本查找

利用遍历数组依次查找

import java.util.ArrayList;

public class basicSearch2 {
    public static void main(String[] args) {
        int num=81;
        int arr[]={131,127,147,81,103,23,7,79,81};
        System.out.println(search(arr,num));
    }
    public static ArrayList<Integer> search(int arr[], int num){
        ArrayList<Integer> list=new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==num){list.add(i);}
        }
        return list;
    }
}

②二分查找

适用于已排序好的数组，从中间数开始查找，依次范围减半，直到找到

import java.util.ArrayList;

public class binarySearch {
    public static void main(String[] args) {
        int num=81;
        int arr[]={7,7,23,71,81,81,81,127,145,147,200};
        System.out.println(Search(arr,num));
    }
    public static ArrayList<Integer> Search(int arr[],int num){
       int max=arr.length-1;
       int min=0;
       ArrayList<Integer> list=new ArrayList<>();


        while (true){
            if(min>max){break;}
            int mid=(max+min)/2;
            if(num>arr[mid]){
                min=mid+1;
            }
            if(num<arr[mid]){
                max=mid-1;
            }
            if(num==arr[mid]){
                list.add(mid);
                int left = mid - 1;
                while (left >= min && arr[left] == num) {
                    list.add(left);
                    left--;
                }

                int right = mid + 1;
                while (right <= max && arr[right] == num) {
                    list.add(right);
                    right++;
                }
                break;
            }
        } return list;
    }
}

③分块查找

适用于有一定规律的数组，一般分成数据开根号块，每个块最小值大于上一块的最大值，遵循块内无序，块外有序，利用最大值确定想查找数据在哪一块中，块内挨个查找

public class blockSearch {
    public static void main(String[] args) {
        int arr[]={16,5,9,12,21,18,
                32,23,37,26,45,34,
                50,48,60,52,73,66};

        block b1=new block(21,0,5);
        block b2=new block(45,6,11);
        block b3=new block(73,12,17);
        block[] blockArr={b1,b2,b3};
        int number=23;
        int index=getIndex(blockArr,arr,number);
        System.out.println(index);
    }
    private static int getIndex(block[] blockArr,int arr[],int number){
        int indexBlock=findIndexBlock(blockArr,number);
        if(indexBlock==-1){return -1;}
        int startIndex=blockArr[indexBlock].getStartIndex();
        int endIndex=blockArr[indexBlock].getEndIndex();
        for (int i = startIndex; i < endIndex; i++) {
            if(arr[i]==number){return i;}

        }
        return -1;

    }
    public static int findIndexBlock(block[] blockArr,int number){
        for (int i = 0; i < blockArr.length; i++) {
            if (number<=blockArr[i].getMax()) {
                return i;
            }

        }
        return  -1;
    }
}
class block{
    private int max;
    private int startIndex;
    private int endIndex;


    public block() {
    }

    public block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }


    public int getMax() {
        return max;
    }


    public void setMax(int max) {
        this.max = max;
    }


    public int getStartIndex() {
        return startIndex;
    }


    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }


    public int getEndIndex() {
        return endIndex;
    }


    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

④插值查找

要求数据分布均匀，原理是确定想查找数在数组中的大概位置后再查找

mid=min+(key-arr[min])/(arr[max]-arr[min])*(max-min)

import java.util.ArrayList;

public class InterpolationSearch {
    public static void main(String[] args) {
        int arr[]={0,1,2,3,4,5,6,7,7,8};
        int num=7;
        System.out.println(search(arr,num));
    }
    public static ArrayList<Integer> search(int arr[],int num){
        ArrayList<Integer> list=new ArrayList<>();
        int min=0;
        int max=arr.length-1;
        while (true){
            if(min>max){break;}
            int mid=min+(num-arr[min])/(arr[max]-arr[min])*(max-min);
            if(num>arr[mid]){
                min=mid+1;
            }
            if(num<arr[mid]){
                max=mid-1;
            }
            if(num==arr[mid]){
                list.add(mid);
                int left = mid - 1;
                while (left >= min && arr[left] == num) {
                    list.add(left);
                    left--;
                }

                int right = mid + 1;
                while (right <= max && arr[right] == num) {
                    list.add(right);
                    right++;
                }
                break;
            }
        } return list;
        }

    }