常见算法(顺序查找,二分查找,分块查找)

基本查找（顺序查找）

package seach;

import java.util.ArrayList;

public class A01_BasicSearchDemo1 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,5,7,8};
        int number = 5;
        String s = basicSearch(arr, number);
        System.out.println(s);

    }
    public static String basicSearch(int[] arr , int  number){
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number){
                list.add(i);
            }
        }
        return list.toString();
    }
}

二分查找

提前查找效率，数据必须是有序的，min和max表示当前要查找的范围

mid是在min和max中间的 如果要查找的元素在mid的左边，缩小范围时，min不变，max等于mid减1

如果要查找的元素在mid的右边，缩小范围时，max不变，min等于mid加1

package seach;

public class A02_BinarySearchDemo2 {
    public static void main(String[] args) {
        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        int number = 147;
        int bs = binarysearch(arr, number);
        System.out.println(bs);
    }

    private static int binarysearch(int[] arr, int number) {
        int min = 0;
        int max = arr.length - 1;
        while (true) {
            if (min > max || max < min) {
                System.out.println("当前查找数据不存在");
                return -1;
            }
            int mid = (min + max) / 2;
            if (arr[mid] < number) {
                min = mid + 1;
            } else if (arr[mid] > number) {
                max = mid - 1;
            } else {
                return mid;
            }
        }
    }
}

分块查找

原则1：前一块中的最大数据，小于后一块中的所有数据（块内无序，块间有序）

原则2：块数数量一般等于数字的个数开根号。

package seach;

public class A03_BlockSearchDemo {
    public static void main(String[] args) {
        int[] arr ={16,5,9,12,21,18,
        32,23,37,26,45,34,
        50,48,61,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 = 34;
        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;
    }
    private 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;
    }
}